庖丁解牛fqrouter - 整体构成

• • Introduction to Laravel Framework
• • Architecture of Laravel Applications
• • 利用Google Analytics追踪分析邮件营销的实例
• • 免费云空间/VPS AppFog申请及Python Web应用开发实战
• • Creating, Validating, and Testing Boot Images
• • iSCSitarget: create differencing VHD
• • 微软说“Windows 11 PC 比 Windows 10 PC 快 2.3 倍”

引用 Test 2015-10-24 19:25

本帖最后由 Test 于 2015-10-24 19:32 编辑

fqrouter为了解决可访问性问题，接入到自由的网络要解决的第一个问题就是DNS。DNS不仅仅是查询一个域名能够拿到IP那么简单，光DNS就可以分解为如下的子问题：

• DNS的配置
• 域名解析的正确性
• 联通电信的线路优化
• Host文件的管理
  

DNS的配置
如果我们以前使用的是socks5（ssh）代理，根本不会有DNS劫持的问题，因为域名是由远端的sock5代理服务器解析的。如果我们以前使用的是VPN代理，而且DNS服务器是国外的，那么DNS解析也不会是问题，VPN代理会保护我们的DNS解析操作。DNS问题只有在翻墙与访问的设备不在一台机器上时才会是问题。如果是socks5代理，要求用户配置浏览器，让浏览器利用socks5代理服务器解析域名。如果是VPN代理，要求用户配置DNS服务器的IP到国外的服务器。fqrouter做为一个路由器设备，显然不希望用户重新手工配置每一个接入了fqrouter网络的设备。所以，这里解决的主要是一个是否需要手工配置的问题。
fqrouter对于配置问题的解决办法是暴力的。对于手机自身的网络流量，使用一条iptables规则解决问题：
iptables -t nat -I OUTPUT -p udp ! -s 10.1.2.3 --dport 53 -j DNAT --to-destination 10.1.2.3:5353对于加入fqrouter网络的设备产生的DNS查询，使用另外一条iptables规则：
iptables -t nat -I PREROUTING -p udp ! -s 10.1.2.3 --dport 53 -j DNAT --to-destination 10.1.2.3:5353这两台规则劫持了所有目标端口号是DNS端口号（53）的UDP连接。虽然浏览器仍然认为它连接的是系统配置的DNS服务器（比如8.8.8.8），但其实真正连接到的是10.1.2.3:5353这个端口的DNS服务器。
这种iptables的暴力做法显而易见的好处是完全不需要在设备或者浏览器上做任何配置。只要DNS查询经过了fqrouter所在的机器，就会被劫持到fqrouter提供的DNS服务器上。
上面的iptables规则中有一个诡异的地方时排除了所有来源地址是10.1.2.3的连接。这是因为把流量倒给了fqdns之后，fqdns自己还是需要去查询上级DNS的。而这些查询为了避免被这两条iptables规则再次劫持，就必须绑定到10.1.2.3这个源IP做查询，然后在iptables规则里排除掉这些查询。否则就死循环了。这种排除法除了可以用排除源IP的方法，还可以使用–mark或者–owner利用mark或者进程的用户/组的ID做排除。不过在Android手机是不能保证所有的手机都支持–mark和–owner，只有比较新的手机才支持。
域名解析的正确性
直接使用国外的DNS服务器，是不能解析出很多了域名的正确结果的。原因是GFW抢答了错误答案。解决办法是记录一个GFW抢答的错误答案的黑名单，如果发现答案是黑名单中的，则丢弃等待DNS服务器回答的正确答案。有的时候，GFW会对DNS查询丢包，这样无论等待多久也不会收到DNS服务器回答的正确答案了。这个时候需要切换到TCP协议，查询DNS服务器。虽然GFW可以对DNS over TCP做关键字检查，但是目前还没有大规模使用。所以在目前的形势下，用黑名单结合DNS over TCP就可以比较完美的解决域名解析的正确性问题。
这部分的代码实现是由fqdns子项目提供的。前面通过iptables重定向到的DNS服务器，就是fqdns。fqdns自身是一个DNS服务器，所有的DNS查询先由fqdns接收，然后再由fqdns查询上一级的DNS服务器。
使用–strategy pick-right参数启动fqdns就实现了GFW的错误答案黑名单。
使用–fallback-timeout 3参数启动fqdns就实现了超时之后切换到DNS over TCP。
联通电信的线路优化
因为国内有很多网站都是有联通和电信两种线路的。当用户以联通的IP去做域名解析的时候，得到的是联通线路的服务器地址。当用户以电信的IP去做域名解析的时候，得到的就是电信线路的服务器地址。如果联通的用户拿到的是电信的服务器地址，访问速度就会变得慢很多。如果我们用8.8.8.8做域名解析，8.8.8.8再去向权威服务器查询域名，那么8.8.8.8就是权威DNS服务器认为的客户端。如果它认为8.8.8.8是电信线路更优的话，即便是联通的用户，也会被分配到电信的服务器地址。
这个问题没有一个特别好的办法。我们不能使用联通、电信分配给你的DNS服务器。因为用这些国内的DNS服务器，是无论如何无法保证域名解析的正确性的。我们也不能总是依赖8.8.8.8这些国外的服务器，因为它不能保证线路的最优。fqdns的实现办法是内置一个国内比较大的网站的域名列表。对于这些域名的解析，使用114dns来做DNS查询。至于是否选择了告诉的线路，这就要靠114dns来保证了。
使用–enable-china-domain –china-upstream 114.114.114.114参数启动fqdns实现了对国内域名解析的线路优化。
Host文件的管理
Host文件可以对某些域名指定IP。这种方式对于google这样的网站来说特别重要。一方面google的ip众多，只要指定的IP没有被GFW关照，就可以获得非常好的使用体验。另外一方面，Google自身封了很多的代理服务器，因为Google不欢迎别人通过代理服务器来爬它的查询结果。而且Google的很多HTTPS服务处于半残废的状态，GFW会以时间为周期完全丢包，造成其服务不稳定的状况。这种丢包是针对特定IP的，只要选择的Google IP没有被关照，就不会出现这样的不稳定状况。
但是Host文件的缺点是需要手工更新。fqrouter显然不希望每次要更新Google的IP都让用户升级一个新的版本。解决办法就是对于指定的域名，比如说google.com，改成google.com.fqrouter.com来解析。这样fqrouter就可以控制google.com解析的结果了，相当于在云端保存了一份公共的Host文件。
使用–enable-hosted-domain –hosted-at fqrouter.com启动fqdns就可以达到关照特殊域名的目的。哪些域名被特殊处理是内置的，基本上都是google的域名。
fqdns-master.zip (66.8 KB, 下载次数: 0)

2015-10-24 19:32 上传

点击文件名下载附件

引用 Test 2015-10-24 19:56

解决可访问性问题除了DNS是远远不够的。为了避免关键字触发连接重置，以及能够访问IP被封的网站，还需要代理服务器。fqrouter使用子项目fqsocks处理代理连接。其解决了如下的问题：

• 代理的配置
• 走什么样的代理
• 直连优化
• 代理服务器失效检测
• 多代理并用
• 代理服务器的地址获取
  

代理的配置
传统的代理使用方式是设置浏览器，要么是socks要么是http代理。如果是浏览器不支持的代理协议，比如shadowsocks或者ssh，就需要在本地启动一个客户端，然后把私有的代理协议转换成浏览器支持的socks/http代理协议。所以相比之下，VPN就要方便很多，一旦启动浏览器不用设置也走代理了。
fqrouter做为路由器显然不希望接入了fqrouter网络的设备还要一个浏览器一个浏览器的去设置。fqsocks和fqdns一样，使用iptables来劫持所有的TCP连接。为什么只有TCP，而不管UDP？因为GFW也不管UDP。
对于手机自身收发的网络流量，使用OUTPUT：
iptables -t nat -I OUTPUT -p tcp ! -s 10.1.2.3 -j DNAT --to-destination 10.1.2.3:8319对于手机做为路由器的过境流量，使用PREROUTING：
iptables -t nat -I PREROUTING -p tcp ! -s 10.1.2.3 -j DNAT --to-destination 10.1.2.3:8319与fqdns同样的道理，排除了来源ip是10.1.2.3的流量，避免无限循环。10.1.2.3:8319接到了TCP请求之后，实际的情况是浏览器认为是直接与目标服务器建立了连接。而8319知道自己不是目标服务器，拿着了别人的连接就要给别人干活的。所以左右拿着与浏览器的TCP连接，右手再与目标服务器建立TCP连接，再在两个TCP连接之间做数据对拷。
browser <=TCP=> 10.1.2.3:8319 (fqsocks) <=TCP=> http server10.1.2.3:8319会特意以10.1.2.3为源IP去与目标服务器建立连接从而避免死循环。这里比fqdns要麻烦的地方在于，对于fqdns来说，上级的DNS服务器可以是写死的，比如8.8.8.8。也就是无论浏览器是用什么DNS服务器做查询，我不管，我始终使用我认为正确的DNS服务器。但是对于fqsocks来说，就必须在与浏览器建立TCP连接的通知，得知浏览器本来的目标服务器是什么。这里是依赖于Linux/iptables的socket API来得知的：
def _get_original_destination(sock, src_ip, src_port):    dst = sock.getsockopt(socket.SOL_IP, SO_ORIGINAL_DST, 16)    dst_port, dst_ip = struct.unpack("!2xH4s8x", dst)    dst_ip = socket.inet_ntoa(dst_ip)    return dst_ip, dst_port这种用iptables做TCP连接劫持，然后用socket api查询真正目标地址，从而实现透明代理的做法是从redsocks抄袭来的。redsocks除了支持iptables，还支持好几种其他的redirector，其获取目标地址的代码在这里：https://github.com/darkk/redsocks/blob/master/base.c
是否走代理
fqsocks左手握着与浏览器的TCP连接，它可以决定右手握着一个什么样的连接。而且它还可以去做不同的尝试，选择一个最好的上级代理。有三种办法：

• 基于IP地址
• 基于域名
• 基于探测
  

最简单的一个选择办法是基于IP地址。比如使用VPN代理的，应该知道chnroutes或者bestreoutetb。这些基于路由表的解决方案是根据目标IP地址选择是否走VPN。fqsocks虽然不是VPN，但是它也可以知道目标IP地址，做一个类似的选择并不困难。fqsocks目前对于来源是局域网，目标也是局域网的TCP连接采取直连的措施。对于所有目标地址是中国国内IP的TCP连接采取直连的措施。这里所谓的直连并不是真正的直连，因为一旦连接落到了fqsocks手上，必然要经过fqsocks代理的。所谓的直连只是fqsocks不经过代理服务器连接目标服务器，但是浏览器仍然是通过fqsocks连接目标服务器的。
第二个选择办法是基于域名。对于socks代理或者http代理，因为是配置浏览器的，浏览器会直接用代理协议告诉代理服务器它要访问的域名。利用switchysharp之类的浏览器插件，或者一些本地的HTTP代理服务器之类的工具是可以做到基于域名选择代理线路的。但是fqsocks要苦难一些。fqsocks是工作TCP层面的代理服务器，其自身并不限制客户端的连接必须是某种协议，比如都是http的。这就要求fqsocks能够在TCP连接的基础上智能检测TCP的字节流里到底跑的是什么协议，然后把域名从协议里提取出来。fqsocks目前可以嗅探两种协议，第一个中明文的http，第二种是https sni里的域名。根据域名fqsocks可以选择最佳的代理服务器。fqsocks目前内置的策略是，如果域名是twitter的域名，总是走代理，无需先测试是否可以连接。因为twitter的ip是被秒封的。
第三个选择方法是试探。这个比前两种更复杂。其工作过程如下，fqsocks探测到TCP里跑的协议是明文的HTTP，所以可能会触发GFW的URL关键字（请求），和全文关键字（响应）。为了知道是否真的会触发。fqsocks用HTTP协议读取出浏览器发送的完整的HTTP请求。然后fqsocks先不急着响应浏览器，它先拿着这个HTTP请求尝试直接与目标服务器交流，等目标服务器给了响应，而且完整无缺的到了fqrouter手上之后再把响应交回给浏览器。如果HTTP请求触发了URL关键字，或者HTTP响应触发了全文关键字，fqsocks就知道直连是没戏了。反正浏览器也不知道。这个时候切换到代理的线路，再重复一遍以上过程就是了。
直连优化
fqsocks自身是用python实现的。用python代理在两个TCP连接之间进行对拷，肯定要比一个直连的TCP连接要慢。这个主要体现在比较高的CPU占用上。虽然fqsocks使用的是python的异步I/O(gevent)，但python毕竟是python。
所以为了能够开着fqrouter挂迅雷下载，我们希望对于可以直连的tcp连接，完全不经过fqsocks。
迅雷 <=TCP=> fqsocks <=TCP=> 国外IP迅雷 <=TCP=> 国内IP要达到这样的目的，就需要在fqsocks的iptables规则之前加上另外一条规则，如果目标地址是国内IP，直接连接。但是问题是，国内的IP不是一个两个啊，用iptables写的话得好多条呢。fqrouter的做法是用nfqueue实现了一个ipset的功能，参见：http://fqrouter.tumblr.com/post/51351094394/android-ipset
代理服务器的失效检测
因为fqsocks是自己用代理的协议连接代理服务器，然后通过代理服务器连接目标服务器的。所以代理服务器是否失效了，通过代理服务器的对与代理协议的不同响应就可以知道。比如说对与goagent
浏览器 <=HTTP=> fqsocks <=GoAgent Protocol=> GoAgent Server <=URL Fetch=> 目标服务器如果fqsocks，连接GoAgent Server得到的响应是503（Over Quota）我们就知道免费的额度今天已经用完了，这个代理就不用再试了。或者
浏览器 <=HTTPS=> fqsocks <=HTTP CONNECT=> Http-Connect代理服务器 <=TCP=> 目标服务器fqsocks在发送了CONNECT命令给代理服务器如果得到的结果是403（Forbidden）的话，就知道这个公开代理已经被加上密码了，不能再用了。
与之前基于探测决定是否走代理同样的原理，即便是发现使用的代理服务器失效了，并不代表浏览器的这个TCP连接就挂了，每个TCP连接有三次选择代理服务器的机会。只要试成功了一次，就可以保住这个TCP连接的正常工作。如果不这么做的话，发先GoAgent超出额度了，出现一个错误页面，然后用户还要再重刷一下。
多代理并用
多代理并用可以有两种策略。一种是对于一个TCP连接，尝试不同的代理，选择最快的那个。另外一种是对于一个TCP连接，只用一个代理。但是不同的TCP连接使用不同的代理。fqsocks的实现方式是每次TCP连接进来，随机从代理池里选择一个使用，如果代理失效了，再选择另外一个。因为一个WEB页面上，除了提供HTML的第一个连接之外，接下来还会开很多加载JS/CSS/图片的TCP连接的。所以实际的效果来说就是，打开一个复杂的页面，可以有好几个代理在同时工作。如果一个代理繁忙，也不会导致整个页面完全打不开。
代理服务器地址的获取
最简单的做法是把代理服务器的地址写在代码里，每次换地址就升级版本。这种做法显然是笨拙的。
第二种做法是搞一个WEB页面，或者HTTP的REST API。问题是在域名被污染，URL关键字被TCP RST的情况下，这样的更新策略是很脆弱的。
fqsocks的做法是利用DNS的TXT记录来分发代理服务器的地址。可以用dig proxy1.fqrouter.com TXT来看效果。
fqsocks-master.zip (252.38 KB, 下载次数: 0)

2015-10-24 19:56 上传

点击文件名下载附件

引用 Test 2015-10-24 20:21

穿墙: fqting-master.zip (4.47 KB, 下载次数: 0)

2015-10-24 20:09 上传

点击文件名下载附件

socks代理转VPN
socks代理是指工作在TCP层面的代理，比如socks4/5或者http代理这些。VPN是指工作在IP层面的代理，比如OpenVPN这些。两者之间的区别是，socks代理是转发二进制字节流，而VPN代理是转发IP包。用黑话来说VPN是L3的，socks代理是L4的。那么出于什么动机会有人希望把socks代理转VPN呢？如果只是为了全局走代理的话，用iptables之类的工具就可以实现全局流量都走L4的代理。其目的是为了支持在Android的手机上不用ROOT就可以使用代理。从Android 4.0开始，支持了一个新的API叫VpnService，使用这个API可以让应用程序启动自己的VPN而不需要手机本身获得ROOT权限（添加iptables规则需要ROOT权限）。但是VpnService的实现是基于tun设备的，也就是在ip包层面的，所以这要求代理能够转发ip包而不是字节流。这也就是为什么OpenVPN可以在Android上实现非ROOT支持，而ssh和socks4/5这些代理却必须要求手机必须先ROOT。
问题是什么？
要全面解析这个tricky的实现要解决的问题在哪，我们先来看最简单形式的scoks代理
浏览器(配置了socks代理）==TCP连接(代理协议）==>socks代理服务器==TCP连接(http)==>目标服务器这是最简单的一种联网方式。浏览器配置过之后知道它不能直接与目标服务器建立TCP连接，所以它就用代理的协议（socks4/5或者http代理协议）与代理服务器建立连接，要求代理服务器帮其连接上目标服务器。这个时候浏览器实际上是不与目标服务器建立直接的TCP连接的。代理服务器自身是在两个连接之间互相拷贝数据。
这种联网方式的缺陷是浏览器需要经过特殊配置。有没有办法不去配置每个具体的应用，在系统的层面设置一个socks代理，然后所有的应用程序就自动应用上了呢？办法是有的，它有一个名字叫做透明代理（transparent socks redirector）。它有另外一个几乎等价的名字叫redsocks。
使用了redsocks之后，联网方式就变得更加复杂了
浏览器（不配置socks代理）==iptables/TCP连接（http）==>redsocks==TCP连接（代理协议）==>socks代理服务器==TCP连接(http)==>目标服务器redsocks在其中干了一件什么龌龊的事情呢？它其实是把自己假装成了目标服务器。浏览器根本不知道它连接上的是代理，它还认为自己是直连目标服务器的呢。因为这个TCP连接的劫持过程是有iptables REDIRECT完成的，所以redsocks可以从系统查询到这个TCP连接其实真正的目标服务器地址是什么，然后它再去用配置好的代理服务器，通过代理连接真正的目标服务器，再把数据拷贝回浏览器与redsocks建立的连接。所以redsocks自身也是一个代理，实现方式也是在两个TCP连接之间对拷数据。
那么VPN是怎么工作的呢？
浏览器==IP包==>VPN客户端建立的虚拟网卡==VPN协议==>VPN服务器端建立的虚拟网卡==IP包转发==>VPN服务器的真正网卡==>目标服务器整个VPN都是工作在IP层面的，所以它不再是字节流的拷贝，而是IP包的转发。那么IP包与字节流之间到区别在哪里？区别就是少了一层TCP协议。按照TCP协议，可以把一组IP包还原成一段字节流。这个还原过程是在Linux内核的TCP/IP实现里完成的。所以这就给我们造成了一个如下图的困境
浏览器==IP包==>Android VpnService建立的虚拟网卡==IP包==>我们的代理程序==TCP连接（socks代理协议）==>socks代理服务器==TCP连接(http）==>目标服务器“我们的代理程序”的左手边从Android VpnService拿到的是IP包，而右手边与socks代理服务器建立的是TCP连接，也就是字节流。这就要求代理程序要做一个IP包的TCP协议重组，从而构建出一个字节流来。但是这怎么能够办到呢？
ShadowSocks Android的解决方法
@ofmax写的ShadowSocks的Android版是我所知的第一个实现Android上socks代理不用ROOT的。其实现方式是这样的。
第一个要解决的问题是怎么样从Android VpnService拿到IP包？VpnService自身的实现是创建一个Linux的tun设备。该设备对外提供的API就是一个file descriptor，也就是一个整数，代表操作系统的一个文件句柄。用file descriptor可以进行文件读，每次读出来的内容就是接收一个ip包，也可以进行文件写，每次写入的内容就是发送一个ip包。问题是该file descriptor是VpnService给java进程的。如果java进程启动了一个子进程，那么这个子进程还能用java进程拿到的这个file descriptor进行IP包的发送和接收吗？
简单来说是不能。为什么不能比较复杂。普通的linux父子进程情况下，子进程是可以访问自己创建之前由父进程打开的file descriptor的。但是java的Runtime.exec的实现里禁止了这样的行为。结果就是如果使用java自己的exec api启动子进程的话，子进程是无法读取父进程的file descriptor的。Shadowsocks的实现方式是不使用java自带的函数启动子进程，使用了jni自己编译了一个新的api来绕过java的限制：https://github.com/shadowsocks/shadowsocks-android/blob/master/src/main/jni/system.cpp
解决了IP包的收发问题之后。更大的问题是如何把IP包转字节流。其实现方式是使用了tun2socks。tun2socks是一个进程，这个进程可以做到左手连接一个tun设备，右手连接一个sock5代理，然后在两者之间做数据对拷。所以使用了tun2socks之后，shadowsocks自身的客户端提供的就是sock5的代理接口，所以这样就接上了：
浏览器==IP包==>Android VpnService建立的虚拟网卡==IP包==>tun2socks==sock5协议==>ShadowSocks客户端==TCP连接（ShadowSocks协议）==>socks代理服务器==TCP连接(http）==>目标服务器那么tun2socks自己又是怎么实现这个IP包转字节流的过程的呢？秘诀在于tun2socks内置了一个lwip实现的TCP/IP栈，相当于重复了Linux的TCP/IP实现，只不过是在用户态做的而不是在内核做的。但是使用tun2socks也带来了新的问题。
问题之一是tun2socks不支持直接传递tun的file descriptor做参数。为此@ofmax的做法是patch了tun2socks，让它可以直接接受tun-fd做为命令行输入。
问题之二是tun2socks只可以把TCP的流量转给sock5代理，对于UDP的流量需要一个remote udp gateway。@ofmax为此在一个国外的服务器上建立了一个公开的remote udp gateway（u.maxcdn.info），所有的udp流量都会从这台服务器转发。
如果你认为这样做就万事大全了你就错了。还有一个问题是如果VpnService可以劫持所有的本地流量走tun设备，那么凭什么shadowsocks的客户端做为一个本地的应用程序不会再次被VpnService劫持呢？这就要看VpnService是怎么把本地流量倒给tun设备的呢。其实现方式是路由表。如果我们在创建这个tun设备的时候设置的路由是0.0.0.0/0就会导致，无论目标地址是何方，都会经过这个tun设备。所以如果路由表是这么设置的话，shadowsocks的客户端是无法工作的，会进入一个死循环。@ofmax的解决办法是把shadowsocks的服务器地址排除在需要走tun设备的路由表之外，这样就解决了死循环的问题。
所以说，让没有ROOT过的Android设备用上ShadowSocks，是非常不容易的。
fqrouter的解决方法
在@ofmax的实现方式的启发下，fqrouter也做了一个实现，同样是利用VpnService，同样是需要把socks代理转成VPN。所以需要解决的问题也是类似的。再重复一下需要解决的问题。

• file descriptor的父子进程问题
• IP包转字节流问题
• 防止死循环，代理自身的连接不走代理
  

首先来解决file descriptor的问题。虽然java启动的子进程没法访问父进程的file descriptor，但是linux有通用的进程间共享file descriptor的机制。黑话就是SCM_RIGHTS。其原理是两个进程之间建立一个unxi domain socket，然后用sendmsg这个linux的api把file descriptor从一个进程发给另外一个进程，设置SCM_RIGHTS这个特殊的标记。在这个一收一发之间，内核就悄无声息地帮我完成了进程之间共享file descriptor的Black Magic：参见http://www.lst.de/~okir/blackhats/node121.html
但是问题是无论是python2.7还是java都不直接提供公开的api让你使用这样的black magic。好消息是Android的SDK让你这么用！Android提供了LocalSocket的api，其中有两个函数

• public void setFileDescriptorsForSend (FileDescriptor[] fds)
• public FileDescriptor[] getAncillaryFileDescriptors ()
  

这两个函数内部就是封装了sendmsg/SCM_RIGHTS这样的magic。对应的python2.7有一个_multiprocessing的内部模块，提供了

• def recvfd(sockfd)
• def sendfd(sockfd, fd)
  

引用 Test 2015-10-24 20:25

利用这几个api就可以解决file descriptor在进程之间共享到问题。也就避免了用JNI实现一个system.exec，可以使用普通的java api启动子进程。接下来要解决IP包转字节流的问题。因为tun2socks需要额外运维一个udp gateway，实际上带来了一个共享的中央服务器，给可用性带来了隐患。我希望能够使用fqdns的实现，不依赖代理服务器直接穿过GFW对DNS的劫持。而且tun2socks内置了lwip也是一个很重的解决方案。TCP/IP栈博大精深，咱最好还是依赖内核的TCP/IP栈吧。所以fqrouter选择了不使用tun2socks。为了说明解决方案，让我们假设tun设备的IP是10.25.1.1/24，现在要访问的目标服务器是8.8.8.8:53。发给tun设备的IP包就会是
10.25.1.1:src_port => 8.8.8.8:53
这个src_port是随机的，由内核分配的。fqrouter从tun设备里读出这个IP包之后经过改写，再重新写入tun设备，也就是重发了一个IP包
10.25.1.100:src_port => 10.25.1.1:12345
这个IP包除了src_ip，src_port，dst_ip，dst_port以及一些checksum不一样之外，与之前收到的IP包完全相同。然后我们在10.25.1.1启动一个类似redsocks的透明代理，这样TCP连接就会直接与10.25.1.1:12345这个服务器建立。于是10.25.1.1:12345就会对我们虚构出来的10.25.1.100这个地址进行应答
10.25.1.1:12345 => 10.25.1.100:src_port
因为10.25.1.100是在tun的网段里，所以tun设备又会读出这个ip，于是再次进行改写：
8.8.8.8:53 => 10.25.1.1:src_port
这样从浏览器的角度来讲，它是认为与8.8.8.8:53建立了直接的TCP连接。其实它是通过tun设备与10.25.1.1:12345建立了TCP连接。这样的实现方式就不需要lwip实现一个用户态的TCP/IP协议栈，但是代价就是要对IP包就行两次NAT，而且需要维护一个NAT的对应表。对应关系是10.25.1.1的src_port做为key，value是原始的TCP连接的目标地址。这个NAT对应关系可以用来给透明代理去请求原始服务器的内容，同时可以做为返回IP包的改写依据。
第三个要解决的问题是如何避免死循环。这需要使用VpnService的protect函数。这个函数接收TCP的socket或者UDP的socket或者一个file descriptor。经过protect的socket收发的数据包就不再经过VPN的tun设备了。同样这里也有file descriptor的跨进程问题。如果在子进程里创建socket，然后把socket的fileno（file descriptor）传递给父进程是无效的。正确的做法是子进程向父进程请求创建socket，父进程创建好socket，运行protect，然后用unix domain socket传递给子进程。
至此socks代理就转成了VPN了。完整代码在github上： https://github.com/fqrouter/fqrouter/tree/master/manager。同时利用以上这个实现，fqrouter从1.14.0开始，翻墙部分可以正常工作在没有ROOT的Android手机上了，下载链接：http://fqrouter.tumblr.com/android-latest。
vpn.py

1. import gevent.monkey
   
2. 
   
3. gevent.monkey.patch_all(ssl=False, thread=False)
   
4. 
   
5. import logging
   
6. import logging.handlers
   
7. import sys
   
8. import os
   
9. import _multiprocessing
   
10. import socket
    
11. import httplib
    
12. import fqdns
    
13. import fqsocks.fqsocks
    
14. import fqsocks.config_file
    
15. import fqsocks.gateways.proxy_client
    
16. import fqsocks.networking
    
17. import contextlib
    
18. import gevent
    
19. import gevent.socket
    
20. import dpkt
    
21. import config
    
22. import traceback
    
23. import urllib2
    
24. import fqsocks.httpd
    
25. 
    
26. FQROUTER_VERSION = 'UNKNOWN'
    
27. LOGGER = logging.getLogger('fqrouter.%s' % __name__)
    
28. LOG_DIR = '/data/data/fq.router2/log'
    
29. MANAGER_LOG_FILE = os.path.join(LOG_DIR, 'manager.log')
    
30. FQDNS_LOG_FILE = os.path.join(LOG_DIR, 'fqdns.log')
    
31. 
    
32. nat_map = {} # sport => (dst, dport), src always be 10.25.1.1
    
33. default_dns_server = config.get_default_dns_server()
    
34. DNS_HANDLER = fqdns.DnsHandler(
    
35.     enable_china_domain=True, enable_hosted_domain=True,
    
36.     original_upstream=('udp', default_dns_server, 53) if default_dns_server else None)
    
37. 
    
38. 
    
39. def handle_ping(environ, start_response):
    
40.     try:
    
41.         LOGGER.info('VPN PONG/%s' % FQROUTER_VERSION)
    
42.     except:
    
43.         traceback.print_exc()
    
44.         os._exit(1)
    
45.     start_response(httplib.OK, [('Content-Type', 'text/plain')])
    
46.     yield 'VPN PONG/%s' % FQROUTER_VERSION
    
47. 
    
48. 
    
49. fqsocks.httpd.HANDLERS[('GET', 'ping')] = handle_ping
    
50. 
    
51. 
    
52. def handle_exit(environ, start_response):
    
53.     gevent.spawn(exit_later)
    
54.     start_response(httplib.OK, [('Content-Type', 'text/plain')])
    
55.     return ['EXITING']
    
56. 
    
57. 
    
58. fqsocks.httpd.HANDLERS[('POST', 'exit')] = handle_exit
    
59. 
    
60. 
    
61. def redirect_tun_traffic(tun_fd):
    
62.     while True:
    
63.         try:
    
64.             redirect_ip_packet(tun_fd)
    
65.         except:
    
66.             LOGGER.exception('failed to handle ip packet')
    
67. 
    
68. 
    
69. def redirect_ip_packet(tun_fd):
    
70.     gevent.socket.wait_read(tun_fd)
    
71.     try:
    
72.         ip_packet = dpkt.ip.IP(os.read(tun_fd, 8192))
    
73.     except OSError, e:
    
74.         LOGGER.error('read packet failed: %s' % e)
    
75.         gevent.sleep(3)
    
76.         return
    
77.     src = socket.inet_ntoa(ip_packet.src)
    
78.     dst = socket.inet_ntoa(ip_packet.dst)
    
79.     if hasattr(ip_packet, 'udp'):
    
80.         l4_packet = ip_packet.udp
    
81.     elif hasattr(ip_packet, 'tcp'):
    
82.         l4_packet = ip_packet.tcp
    
83.     else:
    
84.         return
    
85.     if src != '10.25.1.1':
    
86.         return
    
87.     if dst == '10.25.1.100':
    
88.         orig_dst_addr = nat_map.get(l4_packet.dport)
    
89.         if not orig_dst_addr:
    
90.             raise Exception('failed to get original destination')
    
91.         orig_dst, orig_dport = orig_dst_addr
    
92.         ip_packet.src = socket.inet_aton(orig_dst)
    
93.         ip_packet.dst = socket.inet_aton('10.25.1.1')
    
94.         ip_packet.sum = 0
    
95.         l4_packet.sport = orig_dport
    
96.         l4_packet.sum = 0
    
97.     else:
    
98.         nat_map[l4_packet.sport] = (dst, l4_packet.dport)
    
99.         ip_packet.src = socket.inet_aton('10.25.1.100')
    
100.         ip_packet.dst = socket.inet_aton('10.25.1.1')
     
101.         ip_packet.sum = 0
     
102.         l4_packet.dport = 12345
     
103.         l4_packet.sum = 0
     
104.     gevent.socket.wait_write(tun_fd)
     
105.     os.write(tun_fd, str(ip_packet))
     
106. 
     
107. 
     
108. def get_original_destination(sock, src_ip, src_port):
     
109.     if src_ip != '10.25.1.100': # fake connection from 10.25.1.100
     
110.         raise Exception('unexpected src ip: %s' % src_ip)
     
111.     return nat_map.get(src_port)
     
112. 
     
113. 
     
114. fqsocks.networking.SPI['get_original_destination'] = get_original_destination
     
115. 
     
116. 
     
117. def create_tcp_socket(server_ip, server_port, connect_timeout):
     
118.     fdsock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
     
119.     with contextlib.closing(fdsock):
     
120.         fdsock.connect('\0fdsock2')
     
121.         fdsock.sendall('OPEN TCP,%s,%s,%s\n' % (server_ip, server_port, connect_timeout * 1000))
     
122.         gevent.socket.wait_read(fdsock.fileno())
     
123.         fd = _multiprocessing.recvfd(fdsock.fileno())
     
124.         if fd == 1:
     
125.             LOGGER.error('failed to create tcp socket: %s:%s' % (server_ip, server_port))
     
126.             raise socket.error('failed to create tcp socket: %s:%s' % (server_ip, server_port))
     
127.         sock = socket.fromfd(fd, socket.AF_INET, socket.SOCK_STREAM)
     
128.         os.close(fd)
     
129.         return sock
     
130. 
     
131. 
     
132. fqsocks.networking.SPI['create_tcp_socket'] = create_tcp_socket
     
133. 
     
134. 
     
135. def create_udp_socket():
     
136.     fdsock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
     
137.     with contextlib.closing(fdsock):
     
138.         fdsock.connect('\0fdsock2')
     
139.         fdsock.sendall('OPEN UDP\n')
     
140.         gevent.socket.wait_read(fdsock.fileno())
     
141.         fd = _multiprocessing.recvfd(fdsock.fileno())
     
142.         if fd == 1:
     
143.             LOGGER.error('failed to create udp socket')
     
144.             raise socket.error('failed to create udp socket')
     
145.         sock = socket.fromfd(fd, socket.AF_INET, socket.SOCK_DGRAM)
     
146.         os.close(fd)
     
147.         return sock
     
148. 
     
149. 
     
150. fqdns.SPI['create_udp_socket'] = create_udp_socket
     
151. fqdns.SPI['create_tcp_socket'] = create_tcp_socket
     
152. 
     
153. 
     
154. 
     

复制代码

引用 Test 2015-10-24 20:27

vpn.py

1. import gevent.monkey
   
2. 
   
3. gevent.monkey.patch_all(ssl=False, thread=False)
   
4. 
   
5. import logging
   
6. import logging.handlers
   
7. import sys
   
8. import os
   
9. import _multiprocessing
   
10. import socket
    
11. import httplib
    
12. import fqdns
    
13. import fqsocks.fqsocks
    
14. import fqsocks.config_file
    
15. import fqsocks.gateways.proxy_client
    
16. import fqsocks.networking
    
17. import contextlib
    
18. import gevent
    
19. import gevent.socket
    
20. import dpkt
    
21. import config
    
22. import traceback
    
23. import urllib2
    
24. import fqsocks.httpd
    
25. 
    
26. FQROUTER_VERSION = 'UNKNOWN'
    
27. LOGGER = logging.getLogger('fqrouter.%s' % __name__)
    
28. LOG_DIR = '/data/data/fq.router2/log'
    
29. MANAGER_LOG_FILE = os.path.join(LOG_DIR, 'manager.log')
    
30. FQDNS_LOG_FILE = os.path.join(LOG_DIR, 'fqdns.log')
    
31. 
    
32. nat_map = {} # sport => (dst, dport), src always be 10.25.1.1
    
33. default_dns_server = config.get_default_dns_server()
    
34. DNS_HANDLER = fqdns.DnsHandler(
    
35.     enable_china_domain=True, enable_hosted_domain=True,
    
36.     original_upstream=('udp', default_dns_server, 53) if default_dns_server else None)
    
37. 
    
38. 
    
39. def handle_ping(environ, start_response):
    
40.     try:
    
41.         LOGGER.info('VPN PONG/%s' % FQROUTER_VERSION)
    
42.     except:
    
43.         traceback.print_exc()
    
44.         os._exit(1)
    
45.     start_response(httplib.OK, [('Content-Type', 'text/plain')])
    
46.     yield 'VPN PONG/%s' % FQROUTER_VERSION
    
47. 
    
48. 
    
49. fqsocks.httpd.HANDLERS[('GET', 'ping')] = handle_ping
    
50. 
    
51. 
    
52. def handle_exit(environ, start_response):
    
53.     gevent.spawn(exit_later)
    
54.     start_response(httplib.OK, [('Content-Type', 'text/plain')])
    
55.     return ['EXITING']
    
56. 
    
57. 
    
58. fqsocks.httpd.HANDLERS[('POST', 'exit')] = handle_exit
    
59. 
    
60. 
    
61. def redirect_tun_traffic(tun_fd):
    
62.     while True:
    
63.         try:
    
64.             redirect_ip_packet(tun_fd)
    
65.         except:
    
66.             LOGGER.exception('failed to handle ip packet')
    
67. 
    
68. 
    
69. def redirect_ip_packet(tun_fd):
    
70.     gevent.socket.wait_read(tun_fd)
    
71.     try:
    
72.         ip_packet = dpkt.ip.IP(os.read(tun_fd, 8192))
    
73.     except OSError, e:
    
74.         LOGGER.error('read packet failed: %s' % e)
    
75.         gevent.sleep(3)
    
76.         return
    
77.     src = socket.inet_ntoa(ip_packet.src)
    
78.     dst = socket.inet_ntoa(ip_packet.dst)
    
79.     if hasattr(ip_packet, 'udp'):
    
80.         l4_packet = ip_packet.udp
    
81.     elif hasattr(ip_packet, 'tcp'):
    
82.         l4_packet = ip_packet.tcp
    
83.     else:
    
84.         return
    
85.     if src != '10.25.1.1':
    
86.         return
    
87.     if dst == '10.25.1.100':
    
88.         orig_dst_addr = nat_map.get(l4_packet.dport)
    
89.         if not orig_dst_addr:
    
90.             raise Exception('failed to get original destination')
    
91.         orig_dst, orig_dport = orig_dst_addr
    
92.         ip_packet.src = socket.inet_aton(orig_dst)
    
93.         ip_packet.dst = socket.inet_aton('10.25.1.1')
    
94.         ip_packet.sum = 0
    
95.         l4_packet.sport = orig_dport
    
96.         l4_packet.sum = 0
    
97.     else:
    
98.         nat_map[l4_packet.sport] = (dst, l4_packet.dport)
    
99.         ip_packet.src = socket.inet_aton('10.25.1.100')
    
100.         ip_packet.dst = socket.inet_aton('10.25.1.1')
     
101.         ip_packet.sum = 0
     
102.         l4_packet.dport = 12345
     
103.         l4_packet.sum = 0
     
104.     gevent.socket.wait_write(tun_fd)
     
105.     os.write(tun_fd, str(ip_packet))
     
106. 
     
107. 
     
108. def get_original_destination(sock, src_ip, src_port):
     
109.     if src_ip != '10.25.1.100': # fake connection from 10.25.1.100
     
110.         raise Exception('unexpected src ip: %s' % src_ip)
     
111.     return nat_map.get(src_port)
     
112. 
     
113. 
     
114. fqsocks.networking.SPI['get_original_destination'] = get_original_destination
     
115. 
     
116. 
     
117. def create_tcp_socket(server_ip, server_port, connect_timeout):
     
118.     fdsock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
     
119.     with contextlib.closing(fdsock):
     
120.         fdsock.connect('\0fdsock2')
     
121.         fdsock.sendall('OPEN TCP,%s,%s,%s\n' % (server_ip, server_port, connect_timeout * 1000))
     
122.         gevent.socket.wait_read(fdsock.fileno())
     
123.         fd = _multiprocessing.recvfd(fdsock.fileno())
     
124.         if fd == 1:
     
125.             LOGGER.error('failed to create tcp socket: %s:%s' % (server_ip, server_port))
     
126.             raise socket.error('failed to create tcp socket: %s:%s' % (server_ip, server_port))
     
127.         sock = socket.fromfd(fd, socket.AF_INET, socket.SOCK_STREAM)
     
128.         os.close(fd)
     
129.         return sock
     
130. 
     
131. 
     
132. fqsocks.networking.SPI['create_tcp_socket'] = create_tcp_socket
     
133. 
     
134. 
     
135. def create_udp_socket():
     
136.     fdsock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
     
137.     with contextlib.closing(fdsock):
     
138.         fdsock.connect('\0fdsock2')
     
139.         fdsock.sendall('OPEN UDP\n')
     
140.         gevent.socket.wait_read(fdsock.fileno())
     
141.         fd = _multiprocessing.recvfd(fdsock.fileno())
     
142.         if fd == 1:
     
143.             LOGGER.error('failed to create udp socket')
     
144.             raise socket.error('failed to create udp socket')
     
145.         sock = socket.fromfd(fd, socket.AF_INET, socket.SOCK_DGRAM)
     
146.         os.close(fd)
     
147.         return sock
     
148. 
     
149. 
     
150. fqdns.SPI['create_udp_socket'] = create_udp_socket
     
151. fqdns.SPI['create_tcp_socket'] = create_tcp_socket
     
152. 
     
153. 
     
154. def setup_logging():
     
155.     logging.basicConfig(stream=sys.stdout, level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s')
     
156.     handler = logging.handlers.RotatingFileHandler(
     
157.         MANAGER_LOG_FILE, maxBytes=1024 * 256, backupCount=0)
     
158.     handler.setFormatter(logging.Formatter('%(asctime)s %(levelname)s %(message)s'))
     
159.     logging.getLogger('fqrouter').addHandler(handler)
     
160.     handler = logging.handlers.RotatingFileHandler(
     
161.         FQDNS_LOG_FILE, maxBytes=1024 * 256, backupCount=0)
     
162.     handler.setFormatter(logging.Formatter('%(asctime)s %(levelname)s %(message)s'))
     
163.     logging.getLogger('fqdns').addHandler(handler)
     
164. 
     
165. 
     
166. def exit_later():
     
167.     gevent.sleep(0.5)
     
168.     os._exit(1)
     
169. 
     
170. 
     
171. def read_tun_fd_until_ready():
     
172.     LOGGER.info('connecting to fdsock')
     
173.     while True:
     
174.         tun_fd = read_tun_fd()
     
175.         if tun_fd:
     
176.             return tun_fd
     
177.         else:
     
178.             LOGGER.info('retry in 3 seconds')
     
179.             gevent.sleep(3)
     
180. 
     
181. 
     
182. def read_tun_fd():
     
183.     fdsock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
     
184.     with contextlib.closing(fdsock):
     
185.         try:
     
186.             fdsock.connect('\0fdsock2')
     
187.             fdsock.sendall('TUN\n')
     
188.             gevent.socket.wait_read(fdsock.fileno(), timeout=3)
     
189.             tun_fd = _multiprocessing.recvfd(fdsock.fileno())
     
190.             if tun_fd == 1:
     
191.                 LOGGER.error('received invalid tun fd')
     
192.                 return None
     
193.             return tun_fd
     
194.         except:
     
195.             return None
     
196. 
     
197. 
     
198. class VpnUdpHandler(object):
     
199.     def __init__(self, dns_handler):
     
200.         self.dns_handler = dns_handler
     
201. 
     
202.     def __call__(self, sendto, request, address):
     
203.         try:
     
204.             src_ip, src_port = address
     
205.             dst_ip, dst_port = get_original_destination(None, src_ip, src_port)
     
206.             if 53 ==  get_original_destination(None, src_ip, src_port)[1]:
     
207.                 self.dns_handler(sendto, request, address)
     
208.             else:
     
209.                 sock = fqdns.create_udp_socket()
     
210.                 try:
     
211.                     sock.sendto(request, (dst_ip, dst_port))
     
212.                     response = sock.recv(8192)
     
213.                     sendto(response, address)
     
214.                 finally:
     
215.                     sock.close()
     
216.         except:
     
217.             LOGGER.exception('failed to handle udp')
     
218. 
     
219. fqsocks.fqsocks.DNS_HANDLER = VpnUdpHandler(DNS_HANDLER)
     
220. 
     
221. if '__main__' == __name__:
     
222.     setup_logging()
     
223.     LOGGER.info('environment: %s' % os.environ.items())
     
224.     LOGGER.info('default dns server: %s' % default_dns_server)
     
225.     FQROUTER_VERSION = os.getenv('FQROUTER_VERSION')
     
226.     try:
     
227.         gevent.monkey.patch_ssl()
     
228.     except:
     
229.         LOGGER.exception('failed to patch ssl')
     
230.     args = [
     
231.         '--log-level', 'INFO',
     
232.         '--log-file', '/data/data/fq.router2/log/fqsocks.log',
     
233.         '--tcp-gateway-listen', '10.25.1.1:12345',
     
234.         '--dns-server-listen', '10.25.1.1:12345',
     
235.         '--no-http-manager', # already started before
     
236.         '--no-tcp-scrambler', # no root permission
     
237.     ]
     
238.     args = config.configure_fqsocks(args)
     
239.     fqsocks.fqsocks.init_config(args)
     
240.     fqsocks.config_file.path = '/data/data/fq.router2/etc/fqsocks.json'
     
241.     http_manager_port = fqsocks.config_file.read_config()['http_manager']['port']
     
242.     try:
     
243.         response = urllib2.urlopen('http://127.0.0.1:%s/exit' % http_manager_port, '').read()
     
244.         if 'EXITING' == response:
     
245.             LOGGER.critical('!!! find previous instance, exiting !!!')
     
246.             gevent.sleep(3)
     
247.     except:
     
248.         LOGGER.exception('failed to exit previous')
     
249.     fqsocks.httpd.LISTEN_IP, fqsocks.httpd.LISTEN_PORT = '', http_manager_port
     
250.     fqsocks.httpd.server_greenlet = gevent.spawn(fqsocks.httpd.serve_forever)
     
251.     try:
     
252.         tun_fd = read_tun_fd_until_ready()
     
253.         LOGGER.info('tun fd: %s' % tun_fd)
     
254.     except:
     
255.         LOGGER.exception('failed to get tun fd')
     
256.         sys.exit(1)
     
257.     greenlet = gevent.spawn(redirect_tun_traffic, tun_fd)
     
258.     gevent.spawn(fqsocks.fqsocks.main)
     
259.     greenlet.join()

复制代码

引用 Test 2015-10-24 20:41

无线中继：wifi.py

1. import os
   
2. import logging
   
3. import socket
   
4. import re
   
5. import traceback
   
6. import shlex
   
7. import shutil
   
8. from gevent import subprocess
   
9. import gevent
   
10. 
    
11. import iptables
    
12. import shell
    
13. import hostapd_template
    
14. 
    
15. 
    
16. try:
    
17.     WIFI_INTERFACE = subprocess.check_output(['getprop', 'wifi.interface']).strip() or 'wlan0'
    
18. except:
    
19.     traceback.print_exc()
    
20.     WIFI_INTERFACE = 'wlan0'
    
21. 
    
22. RE_CURRENT_FREQUENCY = re.compile(r'Current Frequency:(\d+\.\d+) GHz \(Channel (\d+)\)')
    
23. RE_FREQ = re.compile(r'freq: (\d+)')
    
24. RE_IFCONFIG_IP = re.compile(r'inet addr:(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})')
    
25. RE_MAC_ADDRESS = re.compile(r'[0-9a-f]+:[0-9a-f]+:[0-9a-f]+:[0-9a-f]+:[0-9a-f]+:[0-9a-f]+')
    
26. RE_DEFAULT_GATEWAY_IFACE = re.compile('default via .+ dev (.+)')
    
27. 
    
28. LOGGER = logging.getLogger('wifi')
    
29. MODALIAS_PATH = '/sys/class/net/%s/device/modalias' % WIFI_INTERFACE
    
30. WPA_SUPPLICANT_CONF_PATH = '/data/misc/wifi/wpa_supplicant.conf'
    
31. P2P_SUPPLICANT_CONF_PATH = '/data/misc/wifi/p2p_supplicant.conf'
    
32. P2P_CLI_PATH = '/data/data/fq.router2/wifi-tools/p2p_cli'
    
33. IW_PATH = '/data/data/fq.router2/wifi-tools/iw'
    
34. HOSTAPD_PATH = '/data/data/fq.router2/wifi-tools/hostapd'
    
35. IWLIST_PATH = '/data/data/fq.router2/wifi-tools/iwlist'
    
36. DNSMASQ_PATH = '/data/data/fq.router2/wifi-tools/dnsmasq'
    
37. KILLALL_PATH = '/data/data/fq.router2/busybox killall'
    
38. IFCONFIG_PATH = '/data/data/fq.router2/busybox ifconfig'
    
39. IP_PATH = '/data/data/fq.router2/busybox ip'
    
40. CP_PATH = '/data/data/fq.router2/busybox cp'
    
41. SH_PATH = '/data/data/fq.router2/busybox sh'
    
42. WHICH_PATH = '/data/data/fq.router2/busybox which'
    
43. FQROUTER_HOSTAPD_CONF_PATH = '/data/data/fq.router2/hostapd.conf'
    
44. CHANNELS = {
    
45.     '2412': 1, '2417': 2, '2422': 3, '2427': 4, '2432': 5, '2437': 6, '2442': 7,
    
46.     '2447': 8, '2452': 9, '2457': 10, '2462': 11, '2467': 12, '2472': 13, '2484': 14,
    
47.     '5180': 36, '5200': 40, '5220': 44, '5240': 48, '5260': 52, '5280': 56, '5300': 60,
    
48.     '5320': 64, '5500': 100, '5520': 104, '5540': 108, '5560': 112, '5580': 116,
    
49.     '5600': 120, '5620': 124, '5640': 128, '5660': 132, '5680': 136, '5700': 140,
    
50.     '5745': 149, '5765': 153, '5785': 157, '5805': 161, '5825': 165
    
51. }
    
52. netd_sequence_number = None # turn off by default
    
53. has_started_before = False
    
54. 
    
55. RULES = [
    
56.     (
    
57.         {'target': 'MASQUERADE', 'source': '10.24.1.0/24', 'destination': '0.0.0.0/0'},
    
58.         ('nat', 'POSTROUTING', '-s 10.24.1.0/24 -j MASQUERADE')
    
59.     ), (
    
60.         {'target': 'MASQUERADE', 'source': '10.1.2.3', 'destination': '0.0.0.0/0'},
    
61.         ('nat', 'POSTROUTING', '-s 10.1.2.3 -j MASQUERADE')
    
62.     ), (
    
63.         {'target': 'ACCEPT', 'source': '0.0.0.0/0', 'destination': '0.0.0.0/0'},
    
64.         ('filter', 'FORWARD', '-j ACCEPT')
    
65.     )]
    
66. 
    
67. 
    
68. def stop_hotspot():
    
69.     try:
    
70.         am_path = shell_execute('%s am' % WHICH_PATH)
    
71.         if am_path:
    
72.             shell_execute('%s %s startservice fq.router2/.wifi_repeater.ReleaseWifiLockService' % (SH_PATH, am_path))
    
73.         working_hotspot_iface = get_working_hotspot_iface()
    
74.         try:
    
75.             shell_execute('%s dnsmasq' % KILLALL_PATH)
    
76.         except:
    
77.             LOGGER.exception('failed to killall dnsmasq')
    
78.         try:
    
79.             shell_execute('%s hostapd' % KILLALL_PATH)
    
80.         except:
    
81.             LOGGER.exception('failed to killall hostapd')
    
82.         try:
    
83.             control_socket_dir = get_p2p_supplicant_control_socket_dir()
    
84.             stop_p2p_persistent_network(control_socket_dir, 'p2p0', 'p2p0')
    
85.             stop_p2p_persistent_network(control_socket_dir, 'p2p0', working_hotspot_iface)
    
86.             delete_existing_p2p_persistent_networks('p2p0', control_socket_dir)
    
87.             shell_execute('%s -p %s -i %s save_config' % (P2P_CLI_PATH, control_socket_dir, 'p2p0'))
    
88.         except:
    
89.             LOGGER.exception('failed to delete existing p2p persistent networks')
    
90.         try:
    
91.             control_socket_dir = get_wpa_supplicant_control_socket_dir()
    
92.             stop_p2p_persistent_network(control_socket_dir, WIFI_INTERFACE, WIFI_INTERFACE)
    
93.             stop_p2p_persistent_network(control_socket_dir, working_hotspot_iface, working_hotspot_iface)
    
94.             delete_existing_p2p_persistent_networks(WIFI_INTERFACE, control_socket_dir)
    
95.             shell_execute('%s -p %s -i %s save_config' % (P2P_CLI_PATH, control_socket_dir, WIFI_INTERFACE))
    
96.         except:
    
97.             LOGGER.exception('failed to delete existing p2p persistent networks')
    
98.         try:
    
99.             netd_execute('softap fwreload %s STA' % WIFI_INTERFACE)
    
100.             shell_execute('netcfg %s down' % WIFI_INTERFACE)
     
101.             shell_execute('netcfg %s up' % WIFI_INTERFACE)
     
102.         except:
     
103.             LOGGER.exception('failed to reload STA firmware')
     
104.         if working_hotspot_iface:
     
105.             try:
     
106.                 shell_execute('%s dev %s del' % (IW_PATH, working_hotspot_iface))
     
107.             except:
     
108.                 LOGGER.exception('failed to delete wifi interface')
     
109.             return ''
     
110.         else:
     
111.             return ''
     
112.     except:
     
113.         LOGGER.exception('failed to stop hotspot')
     
114.         return 'failed to stop hotspot'
     
115. 
     
116. 
     
117. def start_hotspot(ssid, password):
     
118.     global has_started_before
     
119.     has_started_before = True
     
120.     try:
     
121.         am_path = shell_execute('%s am' % WHICH_PATH).strip()
     
122.         if am_path:
     
123.             shell_execute('%s %s startservice fq.router2/.wifi_repeater.AcquireWifiLockService' % (SH_PATH, am_path))
     
124.         backup_config_files()
     
125.         working_hotspot_iface = get_working_hotspot_iface()
     
126.         if working_hotspot_iface:
     
127.             return ''
     
128.         else:
     
129.             LOGGER.info('=== Before Starting Hotspot ===')
     
130.             dump_wifi_status()
     
131.             LOGGER.info('=== Start Hotspot ===')
     
132.             enable_ipv4_forward()
     
133.             wifi_chipset_family, wifi_chipset_model = get_wifi_chipset()
     
134.             LOGGER.info('chipset is: %s %s' % (wifi_chipset_family, wifi_chipset_model))
     
135.             if 'unsupported' == wifi_chipset_family:
     
136.                 return 'wifi chipset [%s] is not supported' % wifi_chipset_model
     
137.             hotspot_interface = start_hotspot_interface(wifi_chipset_family, ssid, password)
     
138.             setup_networking(hotspot_interface)
     
139.             LOGGER.info('=== Started Hotspot ===')
     
140.             dump_wifi_status()
     
141.             return ''
     
142.     except:
     
143.         LOGGER.exception('failed to start hotspot')
     
144.         try:
     
145.             LOGGER.error('=== Failed to Start Hotspot ===')
     
146.             dump_wifi_status()
     
147.         finally:
     
148.             stop_hotspot()
     
149.         return 'failed to start hotspot'
     
150. 
     
151. 
     
152. def backup_config_files():
     
153.     if not os.path.exists('/data/data/fq.router2/backup'):
     
154.         os.mkdir('/data/data/fq.router2/backup')
     
155.     backup_config_file(WPA_SUPPLICANT_CONF_PATH, '/data/data/fq.router2/backup/wpa_supplicant.conf.bak')
     
156.     backup_config_file(P2P_SUPPLICANT_CONF_PATH, '/data/data/fq.router2/backup/p2p_supplicant.conf.bak')
     
157. 
     
158. 
     
159. def backup_config_file(src, dst):
     
160.     try:
     
161.         if os.path.exists(dst):
     
162.             return
     
163.         if shell.USE_SU:
     
164.             content = shell_execute('/data/data/fq.router2/busybox cat %s' % src)
     
165.         else:
     
166.             with open(src) as f:
     
167.                 content = f.read()
     
168.         if 'fqrouter' in content:
     
169.             raise Exception('config file has alreayd been modified by fqrouter')
     
170.         with open(dst, 'w') as f:
     
171.             shell_execute('%s -p %s %s' % (CP_PATH, src, dst))
     
172.     except:
     
173.         LOGGER.exception('failed to backup %s => %s' % (src, dst))
     
174. 
     
175. 
     
176. 
     
177. 
     

复制代码

引用 Test 2015-10-24 20:45

1. def restore_config_files():
   
2.     if os.path.exists('/data/data/fq.router2/backup/wpa_supplicant.conf.bak'):
   
3.         shell_execute(
   
4.             '%s -p %s %s' % (CP_PATH, '/data/data/fq.router2/backup/wpa_supplicant.conf.bak', WPA_SUPPLICANT_CONF_PATH))
   
5.     if os.path.exists('/data/data/fq.router2/backup/p2p_supplicant.conf.bak'):
   
6.         shell_execute(
   
7.             '%s -p %s %s' % (CP_PATH, '/data/data/fq.router2/backup/p2p_supplicant.conf.bak', P2P_SUPPLICANT_CONF_PATH))
   
8. 
   
9. 
   
10. def dump_wifi_status():
    
11.     try:
    
12.         shell_execute('netcfg')
    
13.         get_wifi_chipset()
    
14.         shell_execute('%s phy' % IW_PATH)
    
15.         for iface in list_wifi_ifaces():
    
16.             try:
    
17.                 shell_execute('%s %s channel' % (IWLIST_PATH, iface))
    
18.             except:
    
19.                 LOGGER.exception('failed to log iwlist channel')
    
20.             try:
    
21.                 shell_execute('%s dev %s link' % (IW_PATH, iface))
    
22.             except:
    
23.                 LOGGER.exception('failed to log iw dev link')
    
24.             try:
    
25.                 if 'p2p' in iface or 'ap0' == iface:
    
26.                     control_socket_dir = get_p2p_supplicant_control_socket_dir()
    
27.                 else:
    
28.                     control_socket_dir = get_wpa_supplicant_control_socket_dir()
    
29.                 shell_execute('%s -p %s -i %s status' % (P2P_CLI_PATH, control_socket_dir, iface))
    
30.                 shell_execute('%s -p %s -i %s list_network' % (P2P_CLI_PATH, control_socket_dir, iface))
    
31.             except:
    
32.                 LOGGER.exception('failed to log wpa_cli status')
    
33.         for pid in os.listdir('/proc'):
    
34.             cmdline_path = '/proc/%s/cmdline' % pid
    
35.             if os.path.exists(cmdline_path):
    
36.                 with open(cmdline_path) as f:
    
37.                     cmdline = f.read()
    
38.                     if 'supplicant' in cmdline:
    
39.                         LOGGER.info('pid %s: %s' % (pid, cmdline))
    
40.                         try:
    
41.                             shell_execute('/data/data/fq.router2/busybox ls -a -l /proc/%s/cwd' % pid)
    
42.                         except:
    
43.                             LOGGER.exception('failed to dump supplicant working directory')
    
44.                         dump_wpa_supplicant(cmdline)
    
45.         try:
    
46.             dump_unix_sockets()
    
47.         except:
    
48.             LOGGER.exception('failed to dump unix sockets')
    
49.     except:
    
50.         LOGGER.exception('failed to dump wifi status')
    
51. 
    
52. 
    
53. def dump_wpa_supplicant(cmdline):
    
54.     pos_start = cmdline.find('-c')
    
55.     if -1 == pos_start:
    
56.         return
    
57.     pos_end = cmdline.find('\0', pos_start + 2)
    
58.     if -1 == pos_end:
    
59.         return
    
60.     cfg_path = cmdline[pos_start + 2: pos_end].replace('\0', '')
    
61.     cfg_path_exists = os.path.exists(cfg_path) if cfg_path else False
    
62.     LOGGER.info('cfg path: %s [%s]' % (cfg_path, cfg_path_exists))
    
63.     if cfg_path_exists:
    
64.         with open(cfg_path) as f:
    
65.             content = f.read()
    
66.             for line in content.splitlines():
    
67.                 if 'psk=' in line:
    
68.                     continue
    
69.                 LOGGER.info(line)
    
70.         control_socket_dir = parse_wpa_supplicant_conf(content)
    
71.         LOGGER.info('parsed control socket dir: %s' % control_socket_dir)
    
72.         dump_dir(control_socket_dir)
    
73.     dump_wpa_supplicant(cmdline[pos_end:])
    
74. 
    
75. 
    
76. def dump_dir(dir):
    
77.     if os.path.exists(dir):
    
78.         LOGGER.info('dump %s: %s' % (dir, os.listdir(dir)))
    
79.     else:
    
80.         LOGGER.error('dir %s does not exist' % dir)
    
81. 
    
82. 
    
83. def dump_unix_sockets():
    
84.     LOGGER.info('dump unix sockets')
    
85.     with open('/proc/net/unix') as f:
    
86.         lines = f.readlines()
    
87.     for line in lines:
    
88.         line = line.strip()
    
89.         if not line:
    
90.             continue
    
91.         if '/' in line:
    
92.             LOGGER.info(line)
    
93. 
    
94. 
    
95. def get_working_hotspot_iface():
    
96.     try:
    
97.         hotspot_iface = get_p2p_persistent_iface() or get_working_hotspot_iface_using_nl80211()
    
98.         if WIFI_INTERFACE == hotspot_iface:
    
99.             return None
    
100.         else:
     
101.             return hotspot_iface
     
102.     except:
     
103.         LOGGER.exception('failed to get working hotspot iface')
     
104.         return None
     
105. 
     
106. 
     
107. def get_working_hotspot_iface_using_nl80211():
     
108.     try:
     
109.         ifaces = list_wifi_ifaces()
     
110.         for iface, is_hotspot in ifaces.items():
     
111.             if is_hotspot:
     
112.                 return iface
     
113.         return None
     
114.     except:
     
115.         LOGGER.exception('failed to get working hotspot iface using nl80211')
     
116.         return None
     
117. 
     
118. 
     
119. def list_wifi_ifaces():
     
120.     ifaces = {}
     
121.     current_iface = None
     
122.     for line in shell_execute('%s dev' % IW_PATH).splitlines(False):
     
123.         line = line.strip()
     
124.         if not line:
     
125.             continue
     
126.         if line.startswith('Interface '):
     
127.             current_iface = line.replace('Interface ', '')
     
128.             ifaces[current_iface] = False
     
129.             continue
     
130.         if 'type AP' in line or 'type P2P-GO' in line:
     
131.             ifaces[current_iface] = True
     
132.     return ifaces
     
133. 
     
134. 
     
135. def start_hotspot_interface(wifi_chipset_family, ssid, password):
     
136.     try:
     
137.         shell_execute('start p2p_supplicant')
     
138.     except:
     
139.         LOGGER.exception('failed to start p2p_supplicant')
     
140.     if 'bcm' == wifi_chipset_family:
     
141.         start_hotspot_on_bcm(ssid, password)
     
142.     elif 'wcnss' == wifi_chipset_family:
     
143.         start_hotspot_on_wcnss(ssid, password)
     
144.     elif 'ti' == wifi_chipset_family:
     
145.         start_hotspot_on_ti(ssid, password)
     
146.     elif 'mtk' == wifi_chipset_family:
     
147.         is_jiecao = shell_execute('getprop ro.product.model').strip().startswith('Charmpin')
     
148.         if is_jiecao:
     
149.             start_hotspot_on_bcm(ssid, password)
     
150.         else:
     
151.             try:
     
152.                 start_hotspot_on_mtk(ssid, password)
     
153.             except:
     
154.                 LOGGER.exception('failed to start_hotspot_on_mtk, try bcm way')
     
155.                 try:
     
156.                     shell_execute('start p2p_supplicant')
     
157.                 except:
     
158.                     LOGGER.exception('failed to start p2p_supplicant')
     
159.                 start_hotspot_on_bcm(ssid, password)
     
160.     else:
     
161.         raise Exception('wifi chipset family %s is not supported: %s' % wifi_chipset_family)
     
162.     hotspot_interface = get_working_hotspot_iface()
     
163.     if not hotspot_interface:
     
164.         try:
     
165.             shell_execute('logcat -d -v time -s wpa_supplicant:V')
     
166.         except:
     
167.             LOGGER.exception('failed to log wpa_supplicant')
     
168.         try:
     
169.             shell_execute('logcat -d -v time -s p2p_supplicant:V')
     
170.         except:
     
171.             LOGGER.exception('failed to log p2p_supplicant')
     
172.         try:
     
173.             shell_execute('logcat -d -v time -s WifiP2pService:V')
     
174.         except:
     
175.             LOGGER.exception('failed to log WifiP2pService')
     
176.         raise Exception('working hotspot iface not found after start')
     
177.     return hotspot_interface
     
178. 
     
179. 
     
180. def wait_for_upstream_wifi_network_connected():
     
181.     for i in range(5):
     
182.         gevent.sleep(1)
     
183.         if get_ip_and_mac(WIFI_INTERFACE)[0]:
     
184.             return True
     
185.         try:
     
186.             default_gateway_iface = get_default_gateway_iface()
     
187.             if default_gateway_iface \
     
188.                 and 'p2p' not in default_gateway_iface \
     
189.                 and 'ap0' not in default_gateway_iface \
     
190.                 and WIFI_INTERFACE not in default_gateway_iface:
     
191.                 shell_execute('netcfg %s down' % default_gateway_iface)
     
192.                 shell_execute('netcfg %s up' % default_gateway_iface)
     
193.         except:
     
194.             LOGGER.exception('failed to toggle 3G interface to force wlan reconnect')
     
195.     return False
     
196. 
     
197. 
     
198. def get_default_gateway_iface():
     
199.     try:
     
200.         output = shell_execute('%s route' % IP_PATH)
     
201.         match = RE_DEFAULT_GATEWAY_IFACE.search(output)
     
202.         if match:
     
203.             return match.group(1)
     
204.     except:
     
205.         LOGGER.exception('failed to get default gateway interface')
     
206. 
     
207. 
     
208. def get_ip_and_mac(ifname):
     
209.     try:
     
210.         output = shell_execute('%s %s' % (IFCONFIG_PATH, ifname)).lower()
     
211.         match = RE_MAC_ADDRESS.search(output)
     
212.         if match:
     
213.             mac = match.group(0)
     
214.         else:
     
215.             mac = None
     
216.         match = RE_IFCONFIG_IP.search(output)
     
217.         if match:
     
218.             ip = match.group(1)
     
219.         else:
     
220.             ip = None
     
221.         return ip, mac
     
222.     except:
     
223.         LOGGER.exception('failed to get ip and mac: %s' % ifname)
     
224.         return None, None
     
225. 
     
226. 
     

复制代码

引用 Test 2015-10-24 20:49

1.     def get_wifi_chipset():
   
2.     chipset = get_mediatek_wifi_chipset() or get_wifi_modalias()
   
3.     if chipset:
   
4.     if chipset.endswith('4330'):
   
5.     return 'bcm', '4330'
   
6.     if chipset.endswith('4334'):
   
7.     return 'bcm', '4334'
   
8.     if chipset.endswith('4335'):
   
9.     return 'bcm', '4335'
   
10.     if chipset.endswith('4324'):
    
11.     return 'bcm', '4324' # 43241
    
12.     if chipset.endswith('4076'): # sdio:c00v0097d4076
    
13.     return 'ti', 'wl12xx'
    
14.     if chipset.endswith('A8E7'): # sdio:c00v02D0dA8E7
    
15.     return 'ti', 'wl12xx'
    
16.     if 'platform:wcnss_wlan' == chipset:
    
17.     return 'wcnss', 'unknown'
    
18.     if 'platform:wl12xx' == chipset:
    
19.     return 'ti', 'wl12xx'
    
20.     if 'platform:wl18xx' == chipset:
    
21.     return 'ti', 'wl18xx'
    
22.     if chipset.endswith('6620'):
    
23.     return 'mtk', '6620'
    
24.     if chipset.endswith('6628'):
    
25.     return 'mtk', '6628'
    
26.     if chipset.endswith('5931'): # sdio:c00v037Ad5931
    
27.     return 'mtk', '5931'
    
28.     else:
    
29.     if shell_execute('getprop ro.mediatek.platform').strip():
    
30.     return 'mtk', 'unknown'
    
31.     if os.path.exists('/sys/module/bcmdhd'):
    
32.     return 'bcm', 'unknown'
    
33.     if os.path.exists('/sys/module/wl12xx'):
    
34.     return 'ti', 'wl12xx'
    
35.     return 'unsupported', chipset
    
36. 
    
37. 
    
38.     def get_wifi_modalias():
    
39.     if not os.path.exists(MODALIAS_PATH):
    
40.     LOGGER.warn('wifi chipset unknown: %s not found' % MODALIAS_PATH)
    
41.     return ''
    
42.     with open(MODALIAS_PATH) as f:
    
43.     wifi_chipset = f.read().strip()
    
44.     LOGGER.info('wifi chipset: %s' % wifi_chipset)
    
45.     return wifi_chipset
    
46. 
    
47. 
    
48.     def get_mediatek_wifi_chipset():
    
49.     try:
    
50.     return shell_execute('getprop mediatek.wlan.chip').strip()
    
51.     except:
    
52.     LOGGER.exception('failed to get mediatek wifi chipset')
    
53.     return ''
    
54. 
    
55. 
    
56.     def start_hotspot_on_bcm(ssid, password):
    
57.     control_socket_dir = get_wpa_supplicant_control_socket_dir()
    
58.     load_p2p_firmware(control_socket_dir)
    
59.     if 'p2p0' in list_wifi_ifaces():
    
60.     # bcmdhd can optionally have p2p0 interface
    
61.     LOGGER.info('start p2p persistent group using p2p0')
    
62.     shell_execute('netcfg p2p0 up')
    
63.     p2p_control_socket_dir = get_p2p_supplicant_control_socket_dir()
    
64.     delete_existing_p2p_persistent_networks('p2p0', p2p_control_socket_dir)
    
65.     start_p2p_persistent_network('p2p0', p2p_control_socket_dir, ssid, password, sets_channel=True)
    
66.     else:
    
67.     LOGGER.info('start p2p persistent group using %s' % WIFI_INTERFACE)
    
68.     delete_existing_p2p_persistent_networks(WIFI_INTERFACE, control_socket_dir)
    
69.     start_p2p_persistent_network(WIFI_INTERFACE, control_socket_dir, ssid, password, sets_channel=True)
    
70.     log_upstream_wifi_status('after p2p persistent group created', control_socket_dir)
    
71. 
    
72. 
    
73.     def load_p2p_firmware(control_socket_dir):
    
74.     was_using_wifi_network = get_ip_and_mac(WIFI_INTERFACE)[0]
    
75.     log_upstream_wifi_status('before load p2p firmware', control_socket_dir)
    
76.     netd_execute('softap fwreload %s P2P' % WIFI_INTERFACE)
    
77.     reset_wifi_interface()
    
78.     log_upstream_wifi_status('after loaded p2p firmware', control_socket_dir)
    
79.     if was_using_wifi_network:
    
80.     if wait_for_upstream_wifi_network_connected():
    
81.     LOGGER.info('wifi reconnected')
    
82.     else:
    
83.     LOGGER.error('wifi failed to reconnect')
    
84. 
    
85. 
    
86.     def reset_wifi_interface():
    
87.     shell_execute('netcfg %s down' % WIFI_INTERFACE)
    
88.     shell_execute('netcfg %s up' % WIFI_INTERFACE)
    
89.     gevent.sleep(1)
    
90. 
    
91. 
    
92.     def start_hotspot_on_wcnss(ssid, password):
    
93.     control_socket_dir = get_wpa_supplicant_control_socket_dir()
    
94.     load_p2p_firmware(control_socket_dir)
    
95.     product_model = shell_execute('getprop ro.product.model').strip()
    
96.     force_using_wlan0 = product_model.startswith('MI 2') and not 'MI 2A' == product_model
    
97.     if force_using_wlan0:
    
98.     if 'CDMA' == shell_execute('getprop persist.radio.modem').strip(): # MI 2SC
    
99.     force_using_wlan0 = False
    
100.     if 'p2p0' in list_wifi_ifaces() and not force_using_wlan0:
     
101.     LOGGER.info('start p2p persistent group using p2p0')
     
102.     shell_execute('netcfg p2p0 up')
     
103.     p2p_control_socket_dir = get_p2p_supplicant_control_socket_dir()
     
104.     delete_existing_p2p_persistent_networks('p2p0', p2p_control_socket_dir)
     
105.     start_p2p_persistent_network('p2p0', p2p_control_socket_dir, ssid, password, sets_channel=True)
     
106.     else:
     
107.     LOGGER.info('start p2p persistent group using %s' % WIFI_INTERFACE)
     
108.     delete_existing_p2p_persistent_networks(WIFI_INTERFACE, control_socket_dir)
     
109.     start_p2p_persistent_network(WIFI_INTERFACE, control_socket_dir, ssid, password, sets_channel=True)
     
110.     log_upstream_wifi_status('after p2p persistent group created', control_socket_dir)
     
111. 
     
112. 
     
113.     def load_ap_firmware():
     
114.     for i in range(3):
     
115.     try:
     
116.     shell_execute('%s ap0' % IFCONFIG_PATH)
     
117.     return
     
118.     except:
     
119.     pass
     
120.     netd_execute('softap fwreload %s AP' % WIFI_INTERFACE)
     
121.     for i in range(5):
     
122.     gevent.sleep(1)
     
123.     try:
     
124.     shell_execute('%s ap0' % IFCONFIG_PATH)
     
125.     return
     
126.     except:
     
127.     pass
     
128.     raise Exception('failed to start ap0 interface')
     
129. 
     
130. 
     
131.     def start_hotspot_on_mtk(ssid, password):
     
132.     control_socket_dir = get_wpa_supplicant_control_socket_dir()
     
133.     log_upstream_wifi_status('before load ap firmware', control_socket_dir)
     
134.     load_ap_firmware()
     
135.     shell_execute('netcfg ap0 up')
     
136.     gevent.sleep(2)
     
137.     shell_execute('getprop init.svc.ap_daemon') # log ap_daemon status
     
138.     log_upstream_wifi_status('after loaded ap firmware', control_socket_dir)
     
139.     control_socket_dir = get_wpa_supplicant_control_socket_dir()
     
140.     shell_execute('%s -p %s -i ap0 reconfigure' % (P2P_CLI_PATH, control_socket_dir))
     
141.     delete_existing_p2p_persistent_networks('ap0', control_socket_dir)
     
142.     network_index = start_p2p_persistent_network('ap0', control_socket_dir, ssid, password, sets_channel=True)
     
143.     # restart p2p persistent group otherwise the ssid is not usable
     
144.     shell_execute('%s -p %s -i ap0 p2p_group_remove ap0' % (P2P_CLI_PATH, control_socket_dir))
     
145.     shell_execute('%s -p %s -i ap0 p2p_group_add persistent=%s' % (P2P_CLI_PATH, control_socket_dir, network_index))
     
146.     log_upstream_wifi_status('after p2p persistent group created', control_socket_dir)
     
147.     if not get_working_hotspot_iface():
     
148.     raise Exception('failed to use ap firmware to start hotspot')
     
149. 
     
150. 
     
151.     def start_hotspot_on_ti(ssid, password):
     
152.     if 'ap0' not in list_wifi_ifaces():
     
153.     try:
     
154.     shell_execute(
     
155.     '%s dev %s interface add ap0 type managed' % (IW_PATH, WIFI_INTERFACE))
     
156.     except:
     
157.     LOGGER.exception('failed to add ap0')
     
158.     shell_execute(
     
159.     '%s phy phy0 interface add ap0 type managed' % IW_PATH)
     
160.     assert 'ap0' in list_wifi_ifaces()
     
161.     shell_execute('netcfg')
     
162.     try:
     
163.     shell_execute('netcfg ap0 up')
     
164.     except:
     
165.     LOGGER.exception('failed to start ap0')
     
166.     try:
     
167.     shell_execute('netcfg wlan0 down')
     
168.     shell_execute('netcfg ap0 up')
     
169.     shell_execute('netcfg wlan0 up')
     
170.     except:
     
171.     LOGGER.exception('failed to start ap0 after stop wlan0')
     
172.     with open(FQROUTER_HOSTAPD_CONF_PATH, 'w') as f:
     
173.     frequency, channel = get_upstream_frequency_and_channel()
     
174.     f.write(hostapd_template.render(WIFI_INTERFACE, channel=channel or 1, ssid=ssid, password=password))
     
175.     os.chmod(FQROUTER_HOSTAPD_CONF_PATH, 0666)
     
176.     try:
     
177.     shell_execute('%s hostapd' % KILLALL_PATH)
     
178.     except:
     
179.     LOGGER.exception('failed to killall hostapd')
     
180.     LOGGER.info('start hostapd')
     
181.     if start_hostapd():
     
182.     return
     
183.     try:
     
184.     shell_execute('%s dev ap0 del' % IW_PATH)
     
185.     except:
     
186.     LOGGER.exception('failed to delete ap0')
     
187.     LOGGER.info('try start hostapd without ap0')
     
188.     if not start_hostapd():
     
189.     LOGGER.error('failed to start hotspot on ti platform')
     
190. 
     
191. 
     
192.     def start_hostapd():
     
193.     proc = subprocess.Popen(
     
194.     [HOSTAPD_PATH, '-dd', FQROUTER_HOSTAPD_CONF_PATH],
     
195.     cwd='/data/misc/wifi', stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
     
196.     gevent.sleep(2)
     
197.     if proc.poll():
     
198.     LOGGER.error('hostapd failed: %s' % str(proc.communicate()))
     
199.     shell_execute('logcat -d -v time -s hostapd:V')
     
200.     return False
     
201.     else:
     
202.     LOGGER.info('hostapd seems like started successfully')
     
203.     return True
     
204. 
     
205. 
     
206.     def get_upstream_frequency_and_channel():
     
207.     try:
     
208.     output = shell_execute('%s %s channel' % (IWLIST_PATH, WIFI_INTERFACE))
     
209.     for line in output.splitlines():
     
210.     line = line.strip()
     
211.     if not line:
     
212.     continue
     
213.     match = RE_CURRENT_FREQUENCY.search(line)
     
214.     if match:
     
215.     return match.group(1), match.group(2)
     
216.     frequency = get_upstream_frequency()
     
217.     return frequency, CHANNELS.get(frequency)
     
218.     except:
     
219.     LOGGER.exception('failed to get upstream frequency and channel')
     
220.     return None, None
     
221. 
     

复制代码

引用 Test 2015-10-24 20:51

1.      def get_upstream_frequency():
   
2.     try:
   
3.     output = shell_execute('%s dev %s link' % (IW_PATH, WIFI_INTERFACE))
   
4.     for line in output.splitlines():
   
5.     if not line:
   
6.     continue
   
7.     match = RE_FREQ.search(line)
   
8.     if match:
   
9.     return match.group(1)
   
10.     return None
    
11.     except:
    
12.     LOGGER.exception('failed to get upstream frequency')
    
13.     return None
    
14. 
    
15. 
    
16.     def setup_networking(hotspot_interface):
    
17.     control_socket_dir = get_wpa_supplicant_control_socket_dir()
    
18.     setup_network_interface_ip(hotspot_interface, '10.24.1.1', '255.255.255.0')
    
19.     try:
    
20.     shell_execute('%s dnsmasq' % KILLALL_PATH)
    
21.     except:
    
22.     LOGGER.exception('failed to killall dnsmasq')
    
23.     shell_execute('%s -i %s --dhcp-authoritative --no-negcache --user=root --no-resolv --no-hosts '
    
24.     '--server=8.8.8.8 --dhcp-range=10.24.1.2,10.24.1.254,12h '
    
25.     '--dhcp-leasefile=/data/data/fq.router2/dnsmasq.leases '
    
26.     '--pid-file=/data/data/fq.router2/dnsmasq.pid' % (DNSMASQ_PATH, hotspot_interface))
    
27.     log_upstream_wifi_status('after setup networking', control_socket_dir)
    
28. 
    
29. 
    
30.     def setup_lo_alias():
    
31.     setup_network_interface_ip('lo:1', '10.1.2.3', '255.255.255.255')
    
32.     enable_ipv4_forward()
    
33.     shell_execute('iptables -P FORWARD ACCEPT')
    
34.     iptables.insert_rules(RULES, to_fq_chain=False)
    
35. 
    
36. 
    
37.     def setup_network_interface_ip(iface, ip, netmask):
    
38.     shell_execute('%s %s %s netmask %s' % (IFCONFIG_PATH, iface, ip, netmask))
    
39. 
    
40. 
    
41.     def enable_ipv4_forward():
    
42.     LOGGER.info('enable ipv4 forward')
    
43.     if shell.USE_SU:
    
44.     shell_execute('/data/data/fq.router2/busybox echo 1 > /proc/sys/net/ipv4/ip_forward')
    
45.     else:
    
46.     with open('/proc/sys/net/ipv4/ip_forward', 'w') as f:
    
47.     f.write('1')
    
48. 
    
49. 
    
50.     def log_upstream_wifi_status(log, control_socket_dir):
    
51.     try:
    
52.     LOGGER.info('=== %s ===' % log)
    
53.     shell_execute('%s -p %s -i %s status' % (P2P_CLI_PATH, control_socket_dir, WIFI_INTERFACE))
    
54.     shell_execute('%s dev %s link' % (IW_PATH, WIFI_INTERFACE))
    
55.     shell_execute('netcfg')
    
56.     except:
    
57.     LOGGER.exception('failed to log upstream wifi status')
    
58. 
    
59. 
    
60.     def start_p2p_persistent_network(iface, control_socket_dir, ssid, password, sets_channel=False):
    
61.     wpa_supplicant_control_socket_dir = get_wpa_supplicant_control_socket_dir()
    
62.     try:
    
63.     shell_execute('%s -p %s -i %s p2p_set disabled 0' % (P2P_CLI_PATH, control_socket_dir, iface))
    
64.     except:
    
65.     LOGGER.exception('failed to p2p_set disabled')
    
66.     set_driver_param(control_socket_dir, iface, 'use_p2p_group_interface=1')
    
67.     if iface != WIFI_INTERFACE:
    
68.     try:
    
69.     shell_execute('%s -p %s -i %s p2p_set disabled 0' %
    
70.     (P2P_CLI_PATH, wpa_supplicant_control_socket_dir, WIFI_INTERFACE))
    
71.     except:
    
72.     LOGGER.exception('failed to p2p_set disabled')
    
73.     set_driver_param(wpa_supplicant_control_socket_dir, WIFI_INTERFACE, 'use_p2p_group_interface=1')
    
74.     index = shell_execute('%s -p %s -i %s add_network' % (P2P_CLI_PATH, control_socket_dir, iface)).strip()
    
75. 
    
76.     def set_network(*params):
    
77.     shell_execute([P2P_CLI_PATH, '-p', control_socket_dir, '-i', iface, 'set_network', index] + list(params))
    
78. 
    
79.     set_network('mode', '3')
    
80.     set_network('disabled', '2')
    
81.     set_network('ssid', '\'"%s"\'' % ssid if shell.USE_SU else '"%s"' % ssid)
    
82.     set_network('key_mgmt', 'WPA-PSK')
    
83.     set_network('proto', 'RSN')
    
84.     set_network('pairwise', 'CCMP')
    
85.     set_network('psk', '\'"%s"\'' % password if shell.USE_SU else '"%s"' % password)
    
86.     frequency, channel = get_upstream_frequency_and_channel()
    
87.     if channel:
    
88.     channel = channel if sets_channel else 0
    
89.     reg_class = 81 if sets_channel else 0
    
90.     reset_p2p_channels(iface, control_socket_dir, channel, reg_class)
    
91.     if iface != WIFI_INTERFACE:
    
92.     reset_p2p_channels(WIFI_INTERFACE, wpa_supplicant_control_socket_dir, channel, reg_class)
    
93.     do_p2p_group_add(iface, control_socket_dir, index, frequency)
    
94.     gevent.sleep(2)
    
95.     if get_working_hotspot_iface():
    
96.     return index
    
97.     if 'p2p0' != iface:
    
98.     return index
    
99.     LOGGER.error('restart p2p_supplicant to fix unexpected GO creation')
    
100.     restart_service('p2p_supplicant')
     
101.     do_p2p_group_add('p2p0', control_socket_dir, index, frequency)
     
102.     if get_working_hotspot_iface():
     
103.     return index
     
104.     LOGGER.error('reset wifi interface to fix unexpected GO creation')
     
105.     disable_wifi_p2p_service()
     
106.     shell_execute('stop p2p_supplicant')
     
107.     shell_execute('netcfg wlan0 down')
     
108.     gevent.sleep(1)
     
109.     shell_execute('netcfg wlan0 up')
     
110.     gevent.sleep(1)
     
111.     shell_execute('start p2p_supplicant')
     
112.     gevent.sleep(1)
     
113.     do_p2p_group_add('p2p0', get_p2p_supplicant_control_socket_dir(), index, frequency)
     
114.     return index
     
115. 
     
116. 
     
117.     def do_p2p_group_add(iface, control_socket_dir, index, frequency):
     
118.     try:
     
119.     if frequency:
     
120.     shell_execute('%s -p %s -i %s p2p_group_add persistent=%s freq=%s ' %
     
121.     (P2P_CLI_PATH, control_socket_dir, iface, index, frequency.replace('.', '')))
     
122.     else:
     
123.     shell_execute('%s -p %s -i %s p2p_group_add persistent=%s' %
     
124.     (P2P_CLI_PATH, control_socket_dir, iface, index))
     
125.     except:
     
126.     LOGGER.exception('failed to add p2p group')
     
127. 
     
128. 
     
129.     def disable_wifi_p2p_service():
     
130.     try:
     
131.     if not os.path.exists(P2P_SUPPLICANT_CONF_PATH):
     
132.     return
     
133.     with open(P2P_SUPPLICANT_CONF_PATH) as f:
     
134.     conf = f.read()
     
135.     if '-fqrouter-p2p' in conf:
     
136.     return
     
137.     control_socket_dir = get_p2p_supplicant_control_socket_dir()
     
138.     conf = conf.replace(control_socket_dir, '%s-fqrouter-p2p' % control_socket_dir)
     
139.     with open(P2P_SUPPLICANT_CONF_PATH, 'w') as f:
     
140.     f.write(conf)
     
141.     except:
     
142.     LOGGER.exception('failed to disable wifi p2p service')
     
143. 
     
144. 
     
145.     def enable_wifi_p2p_service():
     
146.     try:
     
147.     if not os.path.exists(P2P_SUPPLICANT_CONF_PATH):
     
148.     return
     
149.     with open(P2P_SUPPLICANT_CONF_PATH) as f:
     
150.     conf = f.read()
     
151.     conf = conf.replace('-fqrouter-p2p', '')
     
152.     with open(P2P_SUPPLICANT_CONF_PATH, 'w') as f:
     
153.     f.write(conf)
     
154.     except:
     
155.     LOGGER.exception('failed to enable wifi p2p service')
     
156. 
     
157. 
     
158.     def restart_service(name):
     
159.     was_running = is_process_exists(name)
     
160.     LOGGER.info('%s was running: %s' % (name, was_running))
     
161.     try:
     
162.     shell_execute('stop %s' % name)
     
163.     except:
     
164.     LOGGER.exception('failed to stop %s' % name)
     
165.     try:
     
166.     shell_execute('start %s' % name)
     
167.     except:
     
168.     LOGGER.exception('failed to start %s' % name)
     
169.     if was_running:
     
170.     gevent.sleep(1)
     
171. 
     
172. 
     
173.     def is_process_exists(name):
     
174.     try:
     
175.     shell_execute('%s -0 %s' % (KILLALL_PATH, name))
     
176.     return True
     
177.     except:
     
178.     return False
     
179. 
     
180. 
     
181.     def set_driver_param(control_socket_dir, iface, param):
     
182.     try:
     
183.     shell_execute(
     
184.     '%s -p %s -i %s set driver_param %s' %
     
185.     (P2P_CLI_PATH, control_socket_dir, iface, param))
     
186.     except:
     
187.     LOGGER.exception('failed to set driver_param %s' % param)
     
188. 
     
189. 
     
190.     def reset_p2p_channels(iface, control_socket_dir, channel, reg_class):
     
191.     try:
     
192.     shell_execute('%s -p %s -i %s set p2p_oper_channel %s' %
     
193.     (P2P_CLI_PATH, control_socket_dir, iface, channel))
     
194.     shell_execute('%s -p %s -i %s set p2p_oper_reg_class %s' %
     
195.     (P2P_CLI_PATH, control_socket_dir, iface, reg_class))
     
196.     shell_execute('%s -p %s -i %s set p2p_listen_channel %s' %
     
197.     (P2P_CLI_PATH, control_socket_dir, iface, channel))
     
198.     shell_execute('%s -p %s -i %s set p2p_listen_reg_class %s' %
     
199.     (P2P_CLI_PATH, control_socket_dir, iface, reg_class))
     
200.     shell_execute('%s -p %s -i %s save_config' % (P2P_CLI_PATH, control_socket_dir, iface))
     
201.     except:
     
202.     LOGGER.exception('failed to reset p2p channels')
     
203. 
     
204. 
     
205.     def get_p2p_persistent_iface():
     
206.     netcfg_output = shell_execute('netcfg')
     
207.     if 'tiwlan' in netcfg_output: # stop further action to avoid mobile restart
     
208.     raise Exception('tiwlan does not support wifi repeater')
     
209.     for line in netcfg_output.splitlines(False):
     
210.     if line.startswith('p2p-'):
     
211.     return line.split(' ')[0]
     
212.     if line.startswith('ap0'):
     
213.     return 'ap0'
     
214.     return None
     
215. 
     
216. 
     
217.     def stop_p2p_persistent_network(control_socket_dir, control_iface, iface):
     
218.     try:
     
219.     shell_execute(
     
220.     '%s -p %s -i %s p2p_group_remove %s' %
     
221.     (P2P_CLI_PATH, control_socket_dir, control_iface, iface))
     
222.     except:
     
223.     LOGGER.error('failed to stop p2p persistent network')
     
224. 
     
225. 
     
226.     def delete_existing_p2p_persistent_networks(iface, control_socket_dir):
     
227.     LOGGER.info('delete existing p2p persistent networks')
     
228.     existing_networks = list_existing_networks(iface, control_socket_dir)
     
229.     for i in sorted(existing_networks.keys(), reverse=True):
     
230.     network = existing_networks[i]
     
231.     if 'P2P-PERSISTENT' in network['status']:
     
232.     delete_network(iface, control_socket_dir, i)
     
233. 
     
234. 
     
235.     def delete_network(iface, control_socket_dir, index):
     
236.     shell_execute(
     
237.     '%s -p %s -i %s remove_network %s' %
     
238.     (P2P_CLI_PATH, control_socket_dir, iface, index))
     
239. 
     

复制代码

引用 Test 2015-10-24 20:53

1.      def list_existing_networks(iface, control_socket_dir):
   
2.     output = shell_execute('%s -p %s -i %s list_network' % (P2P_CLI_PATH, control_socket_dir, iface))
   
3.     LOGGER.info('existing networks: %s' % output)
   
4.     existing_networks = {}
   
5.     for line in output.splitlines(False)[1:]:
   
6.     index, ssid, bssid, status = line.split('\t')
   
7.     existing_networks[int(index)] = {
   
8.     'ssid': ssid,
   
9.     'bssid': bssid,
   
10.     'status': status
    
11.     }
    
12.     return existing_networks
    
13. 
    
14. 
    
15.     def get_p2p_supplicant_control_socket_dir():
    
16.     try:
    
17.     return get_wpa_supplicant_control_socket_dir(P2P_SUPPLICANT_CONF_PATH)
    
18.     except:
    
19.     LOGGER.exception('failed to get p2p supplicant control socket dir')
    
20.     return get_wpa_supplicant_control_socket_dir()
    
21. 
    
22. 
    
23.     def get_wpa_supplicant_control_socket_dir(conf_path=WPA_SUPPLICANT_CONF_PATH):
    
24.     if shell.USE_SU:
    
25.     content = shell_execute('/data/data/fq.router2/busybox cat %s' % conf_path)
    
26.     return parse_wpa_supplicant_conf(content)
    
27.     try:
    
28.     if not os.path.exists(conf_path):
    
29.     raise Exception('can not find wpa_supplicant.conf')
    
30.     with open(conf_path) as f:
    
31.     content = f.read()
    
32.     control_socket_dir = parse_wpa_supplicant_conf(content)
    
33.     if WPA_SUPPLICANT_CONF_PATH == conf_path:
    
34.     control_socket_dir = fix_wrong_control_socket_dir(control_socket_dir)
    
35.     if control_socket_dir:
    
36.     return control_socket_dir
    
37.     else:
    
38.     raise Exception('can not find ctrl_interface dir from wpa_supplicant.conf')
    
39.     except:
    
40.     LOGGER.exception('failed to get wpa_supplicant control socket dir')
    
41.     return '/data/misc/wifi/wpa_supplicant'
    
42. 
    
43. 
    
44.     def fix_wrong_control_socket_dir(control_socket_dir):
    
45.     if os.path.exists('/data/system/wpa_supplicant/%s' % WIFI_INTERFACE):
    
46.     return '/data/system/wpa_supplicant'
    
47.     if os.path.exists('/data/misc/wifi/wpa_supplicant/%s' % WIFI_INTERFACE):
    
48.     return '/data/misc/wifi/wpa_supplicant'
    
49.     if control_socket_dir == WIFI_INTERFACE:
    
50.     return WIFI_INTERFACE
    
51.     if control_socket_dir:
    
52.     control_socket_not_exists = not os.path.exists(
    
53.     os.path.join(control_socket_dir, WIFI_INTERFACE))
    
54.     else:
    
55.     control_socket_not_exists = True
    
56.     dev_socket_exists = os.path.exists('/dev/socket/wpa_%s' % WIFI_INTERFACE)
    
57.     if dev_socket_exists and control_socket_not_exists:
    
58.     return WIFI_INTERFACE # any valid dir will cause wpa_cli fail
    
59.     return control_socket_dir
    
60. 
    
61. 
    
62.     def parse_wpa_supplicant_conf(content):
    
63.     for line in content.splitlines():
    
64.     line = line.strip()
    
65.     if not line:
    
66.     continue
    
67.     if line.startswith('ctrl_interface='):
    
68.     line = line.replace('ctrl_interface=', '')
    
69.     parts = line.split(' ')
    
70.     for part in parts:
    
71.     if part.startswith('DIR='): # if there is DIR=
    
72.     return part.replace('DIR=', '')
    
73.     return line # otherwise just return the ctrl_interface=
    
74.     return None
    
75. 
    
76. 
    
77.     def netd_execute(command):
    
78.     if shell.USE_SU:
    
79.     return shell.launch_python('main', ['netd-execute', '"%s"' % command])
    
80.     global netd_sequence_number
    
81.     netd_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
    
82.     try:
    
83.     netd_socket.connect('/dev/socket/netd')
    
84.     if netd_sequence_number:
    
85.     netd_sequence_number += 1
    
86.     LOGGER.info('send: %s %s' % (netd_sequence_number, command))
    
87.     netd_socket.send('%s %s\0' % (netd_sequence_number, command))
    
88.     else:
    
89.     LOGGER.info('send: %s' % command)
    
90.     netd_socket.send('%s\0' % command)
    
91.     output = netd_socket.recv(1024)
    
92.     LOGGER.info('received: %s' % output)
    
93.     if not netd_sequence_number and 'Invalid sequence number' in output:
    
94.     LOGGER.info('resend command to netd with sequence number')
    
95.     netd_sequence_number = 1
    
96.     netd_execute(command)
    
97.     finally:
    
98.     netd_socket.close()
    
99. 
    
100. 
     
101.     def shell_execute(command):
     
102.     LOGGER.info('execute: %s' % command)
     
103.     try:
     
104.     output = shell.check_output(shlex.split(command) if isinstance(command, basestring) else command)
     
105.     LOGGER.info('succeed, output: %s' % output)
     
106.     except subprocess.CalledProcessError, e:
     
107.     LOGGER.error('failed, output: %s' % e.output)
     
108.     raise
     
109.     return output

复制代码

引用 Test 2015-10-24 20:55

Pick & Play： fqlan-master.zip (4.54 KB, 下载次数: 0)

2015-10-24 20:55 上传

点击文件名下载附件

查看全部评论(11)