昨天学习了下终端界面下的无线网络配置，写下来和大家分享下，也供自己以后忘记了的话可以查询^_^
先介绍两个基本命令：
iwconfig #与ifconfig类似，显示或配置无线网卡的参数
iwlist #显示无线AP的讯息。普通帐户要使用sudo权限才能执行成功。否则提示wlan0 Interface doesn’t support scanning
配置步骤：
0.关闭NetworkManager
1./etc/init.d/NetworkManger stop ＃runlevel 3和5，都要关闭NetworkManager才能手动来配置无线网络1.启用无线网卡
1.ifconfig wlan0 up ＃wlan0是我的无线网卡，你的可能是eth0或者eth1之类的2.搜索SSID
·········10········20········30········40········50········60········70········80········90
1.iwlist wlan0 scanning #这条命令要用root权限来执行，否则提示无线网卡不支持扫描3.设置无线参数
1.iwconfig wlan0 essid "ssid名称" key 无线网络密钥 #16进制密钥使用这条命令 2.iwconfig wlan0 essid "ssid名称" key s:无线网络密钥 #ASCII密钥使用这条命令、4.从无线路由器dhcp获取IP地址，成功后，就可以上网了。
·········10········20········30········40········50········60········70········80········90
1.dhclient wlan0
几个要注意的地方：
1.记得一定要先关闭NetworkManager，此实验才能成功
2.无线网络密码，16进制的密码使用步骤3第一指令，ASCII使用步骤3第二条指令
3.如果要使用ifup wlan0来启用无线网卡，请先确认ifcfg-wlan0这个配置文件是否存在。如果不存在，ifup将不能执行，请改用命令ifconfig wlan0 up
from daemon import Daemon, ServerProxy, Fault, \
error as DaemonError
## #
def usage():
print '使用方法: %s start|stop|status' %sys.argv[0]
def start():
# 读取配置文件
# demo.conf
pyetc.load(schema.ETC('demo.conf'), env=schema.env)
conf = schema.config.daemon
# ... 请见《配置文件一招鲜》最后一个范例
try:
# 创建 Daemon 对象
daemon = Daemon(
address = conf.address, # 进程控制器地址/pid 文件位置
program = conf.program, # 后台进程程序位置
verbose = conf.verbose # 调试
)
print '进程管理器已经启动'
# 启动后台进程
# daemon(arg1, arg2, ...)
# 参数 arg1, arg2 ... 将被用于启动后台进程,
# 这里相当于命令行:
# program.py arg1 arg2 ...
daemon()
except DaemonError, msg:
print '进程管理器未启动, 原因是: ', msg
except:
print_exc(file=stderr)
def stop():
pyetc.load(schema.ETC('demo.conf'), env=schema.env)
conf = schema.config.daemon
# 取得进程控制器
try:
daemon = ServerProxy(conf.address)
daemon.stop()
print '进程已经退出'
except SocketError:
print '进程管理器未启动'
except Fault:
print '进程管理器已被强制关闭'
except:
print_exc(file=stderr)
def status():
pyetc.load(schema.ETC('demo.conf'), env=schema.env)
conf = schema.config.daemon
try:
daemon = ServerProxy(conf.address)
status = daemon.status()
if status == 'running':
print '进程 "%s" 正在运行' %conf.program
elif status == 'stopped':
stdout.write( ('进程管理器正在运行, 但是进程 "%s" 已经停止, '
'正在停止进程管理器 ... '
) %conf.program )
stop()
else:
print '进程管理器正在运行, 进程状态未知'
except SocketError:
print '进程管理器未启动'
except:
print_exc(file=stderr)
## #
# 解析参数
if len(sys.argv) != 2:
usage()
elif sys.argv[1] == 'start':
start()
elif sys.argv[1] == 'stop':
stop()
elif sys.argv[1] == 'status':
status()
else: usage()
第三章、附件: daemon.py
import os, sys
from httplib import HTTP, HTTPConnection
from pwd import getpwnam, getpwuid
from signal import signal as setsignal, SIGCHLD, SIGTERM
from sys import stderr, stdout
from urllib import urlopen
from SocketServer import UnixStreamServer
from socket import socket, error as SocketError, \
AF_UNIX, SOCK_STREAM
from SimpleXMLRPCServer import SimpleXMLRPCDispatcher, \
SimpleXMLRPCRequestHandler, SimpleXMLRPCServer
from xmlrpclib import Fault, Transport, dumps as xmlrpc_dumps, \
_Method as _XMLRPCMethod, ServerProxy as ServerProxy_N___G
from os import execv, chdir, chmod, fork, geteuid, getpid, \
kill, setgid, setuid, umask, unlink, waitpid, \
error as OSError, WNOHANG
class error(Exception): pass
class nul:
write = staticmethod(lambda s: None)
flush = staticmethod(lambda : None)
read = staticmethod(lambda n: '' )
class UnixStreamXMLRPCServer(UnixStreamServer, SimpleXMLRPCDispatcher):
def __init__(self, address, requestHandler=SimpleXMLRPCRequestHandler,
allow_none=False, encoding=None):
self.logRequests = False
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
UnixStreamServer.__init__(self, address, requestHandler)
class Daemon:
def __init__(self, **args):
address = args[ 'address' ]
allow_none = args.get( 'allow_none', True )
encoding = args.get( 'encoding' , 'utf-8' )
self.verbose = args.get( 'verbose' , False )
self.stdout = args.get( 'stdout' , nul )
self.stderr = args.get( 'stderr' , nul )
try:
ServerProxy(address).ping()
except SocketError:
pass
else:
raise error, 'Another daemon is already up using socket %s' %repr(address)
if isinstance(address, str):
try:
unlink(address)
except OSError:
pass
self.manager = UnixStreamXMLRPCServer(address,
allow_none=allow_none, encoding=encoding)
self.pidfile = address
else:
self.manager = SimpleXMLRPCServer(address,
allow_none=allow_none, encoding=encoding)
self.pid = None
self.running = True
self.program = args[ 'program' ]
DaemonizeTools.setuid(
user = args.get( 'user' , None ) )
SignalTools.setsignals(self)
DaemonizeTools.daemonize(
directory = args.get( 'directory' , None ),
umask = args.get( 'umask' , 022 ) )
self.register_function = lambda *args: (
self.manager.register_function(*args) )
self.register_function(lambda: self.stop() , 'stop' )
self.register_function(lambda: self.status(), 'status')
self.register_function(lambda: True , 'ping' )
def __call__(self, *args):
if not self.verbose:
DaemonizeTools.close_files(self.stdout, self.stderr)
del self.stdout, self.stderr
pid = fork()
if pid != 0:
self.pid = pid
while self.running:
self.manager.handle_request()
return pid
else:
try:
for i in xrange(3, 100):
try:
os.close(i)
except OSError:
pass
try:
execv(sys.executable, tuple(
[sys.executable, self.program] + list(args) ) )
except OSError, err:
print >> stderr, ( 'can\'t exec %r: %s\n'
% (self.program, err) )
finally:
os._exit(127)
def status(self):
if not self.pid:
return 'stopped'
else:
return 'running'
def stop(self):
if not self.pid:
self.running = False
if hasattr(self, 'pidfile'):
try:
unlink(self.pidfile)
except OSError:
pass
raise error, 'no subprocess running'
kill(self.pid, SIGTERM)
self.running = False
if hasattr(self, 'pidfile'):
try:
unlink(self.pidfile)
except OSError:
pass
class UnixStreamHTTPConnection(HTTPConnection):
def connect(self):
self.sock = socket(AF_UNIX, SOCK_STREAM)
self.sock.connect(self.host)
class UnixStreamHTTP(HTTP):
_connection_class = UnixStreamHTTPConnection
class UnixStreamTransport(Transport):
def make_connection(self, host):
return UnixStreamHTTP(host)
class UnixStreamServerProxy_NG:
def __init__(self, uri, transport=None, encoding=None, verbose=0,
allow_none=0, use_datetime=0):
self.__host = uri
self.__handler = '/RPC2'
if not transport:
self.__transport = UnixStreamTransport(use_datetime=use_datetime)
self.__encoding = encoding
self.__verbose = verbose
self.__allow_none = allow_none
def __request(self, methodname, params):
request = xmlrpc_dumps(params, methodname, encoding=self.__encoding,
allow_none=self.__allow_none)
response = self.__transport.request(
self.__host, self.__handler, request,
verbose=self.__verbose )
if len(response) == 1:
response = response[0]
return response
def __getattr__(self, name):
return _XMLRPCMethod(self.__request, name)
def ServerProxy(address, **args):
if isinstance(address, str):
return UnixStreamServerProxy_NG(address, **args)
else:
host, port = address
host = (host, '127.0.0.1')[host == '0.0.0.0']
return ServerProxy_N___G('http://%s:%d' %(host, port), **args)
class DaemonizeTools:
@staticmethod
def setuid(**args):
user = args['user']
if user is None:
return
try:
uid = int(user)
except ValueError:
try:
pwrec = pwd.getpwnam(user)
except KeyError:
raise error, 'username %r not found' % user
uid = pwrec[2]
else:
try:
pwrec = pwd.getpwuid(uid)
except KeyError:
raise error, 'uid %r not found' % user
euid = geteuid()
if euid != 0 and euid != uid:
raise error, 'only root can change users'
setgid(pwrec[3])
setuid(uid)
@staticmethod
def daemonize(**args):
pid = fork()
if pid != 0:
os._exit(0)
if args['directory']:
try:
chdir(args['directory'])
except OSError, err:
print >> stderr, ( 'can\'t chdir into %r: %s'
% (args['directory'], err) )
else:
print >> stderr, ( 'set current directory: %r'
% args['directory'] )
os.setsid()
umask(args['umask'])
@staticmethod
def close_files(stdout, stderr):
os.close(0)
sys.stdin = sys.__stdin__ = nul
os.close(1)
sys.stdout = sys.__stdout__ = stdout
os.close(2)
sys.stderr = sys.__stderr__ = stderr
class SignalTools:
daemon = None
@staticmethod
def setsignals(daemon):
SignalTools.daemon = daemon
setsignal(SIGCHLD, SignalTools.sigchild)
@staticmethod
def sigchild(sig, frame):
try:
pid, sts = waitpid(-1, WNOHANG)
if pid == SignalTools.daemon.pid:
SignalTools.daemon.pid = None
except OSError:
return
